@genex-ai/cli-demo 0.94.0-dev.251 → 0.95.0-dev.253

package/templates/skills/genex-game-director/SKILL.md

@@ -196,17 +196,26 @@ skip it during unrelated focused work.
 
 ### When the UI/HUD/menu lane is invoked
 
-The existing owning skills control the full pipeline. Do not simplify or
-bypass their FAL calls, credits, checkpoints, retries, Stage-1/Stage-2 prompts,
-extraction, masks, wiring, markers, nudges, or preflights.
-
-The Stage-1 mockup decides the HUD implementation and `DESIGN.md` records it:
-ornate/painterly/material chrome → `HUD lane: sprites (…)`; flat geometry plus
-typography that CSS can reproduce screenshot-indistinguishably →
-`HUD lane: CSS (…, one-line justification)`. Unsure → sprites. The player's
-explicit lane request wins. Once invoked, follow `$genex-ai-hud` and
-`$genex-ai-menu` exactly, including `Menu video:` and every HUD pipeline state
-marker.
+**Generated UI art is opt-in.** A restrained interface built in clean CSS is a
+finished, legitimate HUD—not a placeholder. Reach for the sprite lane
+(`$genex-ai-hud`) when the game's own style genuinely wants drawn
+chrome—ornate, painterly, comic, hand-made—or when the player asks for HUD art;
+stylized games are where chrome earns its place. The art direction comes from
+the game's brief in words. Generating ONE element you decided the game needs—a
+frame, a mask, an icon, a wordmark, a menu backdrop, a menu video—is a normal,
+first-class use of these tools, never a half-run pipeline.
+
+Judgment governs *whether* art is generated; it never loosens *how well* it is
+done. When you do run a stage, run its quality steps in full: `$genex-ai-hud`
+and `$genex-ai-menu` keep their Stage-1/Stage-2 prompts, FAL calls, credits,
+checkpoints, retries, extraction, masks, wiring, `npx genex ui audit`, nudges,
+and preflights exactly as written, hard refusals included. Choosing to generate
+one element rather than a whole set is a scope decision, not a bypass.
+
+While a sprite or menu-video pipeline is actually in flight, `DESIGN.md` holds
+its state so a context compaction can resume it: `HUD lane:`, `Menu video:`,
+and the HUD pipeline stage IDs and paths. A game whose interface never runs a
+generation lane records nothing there.
 
 In both lanes, micro-text stays HTML text in the chosen font, and no generic
 rectangular plate appears behind bars, digits, or icons; a genuinely shaped
@@ -240,6 +249,12 @@ usefully independent pieces.
   a prose summary.
 - Do not create workers merely to write extra test suites or reports.
 
+When the player asks for parallel work, repeated refinement passes, or a critic
+reviewing your output, that request IS the instruction—wherever it reaches you,
+including inside their answer to a question you asked. Adopt it as the working
+mode immediately, starting with the work in front of you; never file it as a
+later milestone or a final polish pass.
+
 For a substantial, judgeable result in whole coordinated mode, a **fresh
 critic may** inspect the actual game, rendered pixels, reference, or test
 result—not the builder's summary. It returns the single largest meaningful
@@ -264,11 +279,12 @@ head.” A genuinely non-person player (car, ship, RTS cursor, board) uses
 
 When this lane is relevant, put its row in the Assets table and enqueue it
 when its milestone starts—or in parallel when whole coordinated mode makes
-that useful. Its asset-specific concept review is its own beat; it never waits
-for or requires a UI concept. `npx genex controller character` installs the
-controller and fallback body; `loadPlayerCharacter` keeps the boot path stable,
-and `npx genex controller character --character <id>` switches the manifest
-when the generated body lands.
+that useful. Its asset-specific concept review is its own beat—the one concept
+step that survives, because the player is choosing a concrete thing they asked
+for—and it never waits on another lane. `npx genex controller character`
+installs the controller and fallback body; `loadPlayerCharacter` keeps the boot
+path stable, and `npx genex controller character --character <id>` switches the
+manifest when the generated body lands.
 
 The profile VRM avatar is the fallback: a temporary body while generation
 runs, or the stand-in when generation genuinely could not happen, recorded as

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

@@ -47,7 +47,9 @@ so it survives a long pause, context compaction, handoff, and remix.
   appear only when the request or existing project uses them.
 - Preserve every machine-readable marker an invoked pipeline owns, including
   `HUD lane:`, `Menu video:`, HUD stage IDs and paths, `Player character:`,
-  asset generation IDs/URLs, and wiring state.
+  asset generation IDs/URLs, and wiring state. They exist so work already in
+  flight survives a compaction; a lane you never run leaves its markers unwritten
+  and owes no explanation for their absence.
 - A private reference attachment is a build input. Do not upload, publish, or
   commit it without the player's explicit permission.
 
@@ -108,8 +110,10 @@ defaults.)
 
 ## Screens & UI (only when the UI/HUD/menu lane is invoked)
 Screens: <only the requested/required states> · Style brief: <one line>
-HUD lane: <sprites (…) | CSS (…, one-line justification)>
-Menu video: <yes | declined (player's reason) | still fallback (reason)>
+(The two lines below are bookkeeping for a generation lane actually running,
+so a compaction can resume it. An interface built in CSS records neither.)
+HUD lane: sprites (<which elements the sprite lane is producing>)
+Menu video: <generation id/URL, or the still standing in while it renders>
 
 ## Assets — the generation plan AND budget (only when used)
 | Asset | Kind | Status | Wired? |
@@ -119,8 +123,8 @@ Menu video: <yes | declined (player's reason) | still fallback (reason)>
 | <asset> | <kind> | landed → <URL> | yes/no |
 Status flow: proposed → planned → generating (id) → landed (URL) → wired.
 
-**HUD pipeline state (sprites lane) — keep this current; it is how the
-pipeline survives a context compaction.**
+**HUD pipeline state (only while the sprites lane is running) — keep this
+current; it is how that pipeline survives a context compaction.**
 - Stage-1 mockup: <id → URL>
 - Stage-2 sheet: <id → URL>
 - Cleaned sheet: <id → URL>

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

@@ -56,9 +56,9 @@ copy demo architecture.
 | poster, sign, sprite, decal, reference sheet, or other 2D art | `$genex-ai-image` |
 | in-world motion art or another requested video | `$genex-ai-video` |
 | sound effect, one looping music bed, or a short spoken line | `$genex-ai-sfx`, `$genex-ai-music`, or `$genex-ai-voice` |
-| requested UI/HUD/menu/interface work, or the later UI milestone of a complete-game request | `$genex-threejs-game-ui` |
+| requested UI/HUD/menu/interface work, a visible UI problem, or an interface you decided this game wants built with generated art | `$genex-threejs-game-ui` |
 | cinematic menu/title/pause/victory/defeat/lobby/credits video treatment | `$genex-ai-menu` |
-| cohesive art-directed HUD sprite set with matched frames, masks, and icons | `$genex-ai-hud` |
+| drawn HUD chrome the game's style wants—one element or a matched set of frames, masks, and icons | `$genex-ai-hud` |
 | the game works but feels flat, floaty, or unresponsive: input response, camera, impacts, cooldowns, difficulty, fail/retry | `$genex-threejs-game-feel` |
 | realtime multiplayer: movement sync, shared ball/NPC, host-run scores/enemies, shots/emotes, persistence | `$genex-threejs-multiplayer` |
 | player identity, sign-in, guests, saves/progress, per-player state, shared persistent world, leaderboards—mandatory for every game | `$genex-threejs-embed-auth` |
@@ -150,13 +150,18 @@ landed (<local TypeScript path>) → wired`
 
 ### UI, HUD, menu, and FAL
 
-Enter this lane only for a direct UI/HUD/menu request, a relevant visible UI
-problem, or the later interface milestone of a complete-game request. Once
-invoked, `$genex-threejs-game-ui`, `$genex-ai-hud`, `$genex-ai-menu`,
+Enter this lane for a direct UI/HUD/menu request, a relevant visible UI
+problem, or an interface you decided this game's style wants built with
+generated art. Generated UI art is opt-in: a restrained CSS interface is a
+finished HUD, and generating one element—a frame, a mask, an icon, a wordmark,
+a menu backdrop, a menu video—is a normal use of the lane. Once invoked,
+`$genex-threejs-game-ui`, `$genex-ai-hud`, `$genex-ai-menu`,
 `$genex-ai-image`, and `$genex-ai-video` retain their existing Stage-1/Stage-2
 prompts, FAL calls, credits/checkpoints, retries, extraction, masks, wiring,
-markers, nudges, preflights, and approval behavior. Keep `HUD lane:`,
-`Menu video:`, and every HUD pipeline stage ID/path current in `DESIGN.md`.
+markers, nudges, preflights, and approval behavior—the scope is your call, the
+execution quality is theirs. While a sprite or menu-video pipeline is in
+flight, keep `HUD lane:`, `Menu video:`, and every HUD pipeline stage ID/path
+current in `DESIGN.md` so a compaction can resume it.
 
 The absence of generated HUD/menu/concept art alone never interrupts unrelated
 focused work.
@@ -192,6 +197,11 @@ sub-agents. One writer owns each disjoint file set; the director integrates
 shared boot, loop, and netcode files. Focused work skips fan-out unless the
 request itself has independently useful parts.
 
+A player who asks for parallel work, repeated refinement passes, or a critic
+reviewing the work has given the instruction—wherever it reaches you, including
+inside an answer to a question you asked. It becomes the working mode right
+then, on the work in front of you, not a milestone scheduled for later.
+
 For a substantial judgeable result, a fresh critic may inspect the real game,
 rendered pixels, supplied reference, or test output—not a builder summary. It
 returns the single largest meaningful gap; the builder may correct it and ask

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

@@ -52,10 +52,11 @@ npx genex video "waterfall mist drifting" --loop      # a video clip (screen/bac
 
 Each has a focused skill with the exact loader code — `$genex-ai-model`,
 `$genex-ai-skybox`, `$genex-ai-sfx`, `$genex-ai-texture`, `$genex-ai-image`,
-`$genex-ai-video`. For generated game UI there are two workflow skills built
-on the same commands: `$genex-ai-menu` (a cinematic menu — looping video
-backdrop + DOM buttons) and `$genex-ai-hud` (a production HUD sprite set with
-masked fills).
+`$genex-ai-video`. Two more workflow skills draw UI art on the same commands,
+for games whose style wants it: `$genex-ai-menu` (a cinematic menu — looping
+video backdrop + DOM buttons) and `$genex-ai-hud` (a HUD sprite set with
+masked fills). A restrained interface in clean CSS is a finished UI too —
+`$genex-threejs-game-ui` builds that one.
 
 ## Identity & saves (every game)
 

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

@@ -1,6 +1,6 @@
 ---
 name: genex-threejs-game-ui
-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.
+description: Design the UI HUD interface of a Genex Three.js game — work out the screen set this game actually needs (loader, menu, HUD, pause/win/lose, lobby) under one shared art direction, then build it as an animated DOM overlay. Use whenever the game needs on-screen text, meters, buttons, menus, or screens, or when the interface reads as a generic dashboard, covers the action, or shifts as numbers change.
 ---
 
 # Genex Three.js Game UI
@@ -11,201 +11,110 @@ screens fade and stagger in, values tween, defeat feels different from victory.
 This skill is the UI director for the 2D layer of a vanilla Three.js game: the
 plan, the architecture, the states, motion, and readability rules.
 
-## Plan the UI first — before any UI code
+## Work out which screens this game needs
 
-Run this gate ONCE, right after the game concept is locked. It takes two
-minutes and prevents the two failure modes no later polish can fix: a screen
-set discovered piecemeal, and a menu styled in one world while the HUD lives
-in another.
+Two minutes before the first UI file prevents the two failure modes no later
+polish can fix: a screen set discovered piecemeal, and a menu styled in one
+world while the HUD lives in another.
 
 **1. Screen inventory — derived from the game type, not discovered later:**
 
 | Screen | When it exists | Default tier |
 | --- | --- | --- |
 | Loader | always | 1 — branded (see loader spec below) |
-| Main menu | always — the decision defaults to YES for every game; a "no" needs a one-line game-type reason (e.g. an instant-restart arcade toy), and "it's only a draft" is never a reason | 2 — cinematic (`$genex-ai-menu`) |
+| Main menu | most games; a few genuinely don't want one (an instant-restart arcade toy) — but "it's only a draft" is never the reason | 1 — animated CSS title screen; 2 — cinematic (`$genex-ai-menu`) when the game's style wants it |
 | Pause | always — opens on the Escape key | 1 — menu backdrop under a dark overlay |
 | Fail / retry | always | 1 — a *graded* variant of the menu screen |
 | Win / next | always | 1 — graded variant, warm |
 | Settings | always — every game carries the Quality picker (Auto/Low/Medium/High, `$genex-threejs-adaptive-quality`), and any game with generated audio carries **Music + SFX volume sliders** (persisted, applied live; music default 0.30, sfx ~0.7 — `$genex-ai-music`; a paid track with no volume control is a failure mode), plus whatever else it has to set | 1 |
 | Lobby / waiting | multiplayer only | 1 over the menu backdrop |
-| HUD | always | 2 — generated sprite HUD (`$genex-ai-hud`), enqueued at this gate for EVERY game; plain CSS is the placeholder until the sprites land, never the final HUD |
+| HUD | whenever the game shows state the player has to read | 1 — a restrained CSS HUD finished to the readability + motion rules below; 2 — generated sprites (`$genex-ai-hud`) when the game's style wants drawn chrome |
 
 The lobby row is bound by `$genex-threejs-multiplayer`'s MANDATORY rule: the
 waiting overlay's visibility is re-read from `mm.matchmaking.status` every
 frame and closes the instant it flips to `playing` — verified in two browser
 windows. Plan the lobby as a styled screen (roster + count over the menu
-backdrop), not an afterthought `<div>`. When the menu decision is a reasoned
-"no", every "menu backdrop" row above (pause, fail, win, lobby) grades over
-the loader's key art instead.
+backdrop), not an afterthought `<div>`. In a game that genuinely has no menu,
+every "menu backdrop" row above (pause, fail, win, lobby) grades over the
+loader's key art instead.
 
 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.
+damage numbers, kill feeds, timers, countdowns, pickup popups. That written
+list is the authority on WHAT exists: mechanics come from the agreed game,
+never from a picture — a widget that shows up in generated art with no
+backing mechanic is cut before anything wires it.
 
 **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
-store it as a comment block near the UI code. `$genex-ai-menu`,
-`$genex-ai-hud`, the loader, and every plain-CSS screen consume THIS brief
-verbatim — and so does the scene: the visual-direction plan (the router's
-next gate) derives its lighting mood, fog, grading, and post-stack choices
-from the same block. Two style briefs in one game is a bug; a scene graded in
-one world under a UI styled in another is the same bug. The brief's font pair
+store it as a comment block near the UI code. This brief, in WORDS, IS the
+game's art direction: it comes out of the game's own concept and premise, and
+everything downstream reads its palette, materials, and register from here.
+For genre conventions worth borrowing — placement, hierarchy, type treatment,
+material language — skim
+[references/style-capsules.md](references/style-capsules.md).
+`$genex-ai-menu`, `$genex-ai-hud`, the loader, and every plain-CSS screen
+consume THIS brief verbatim — and so does the scene: the visual-direction
+plan derives its lighting mood, fog, grading, and post-stack choices from the
+same block. Two style briefs in one game is a bug; a scene graded in one
+world under a UI styled in another is the same bug. The brief's font pair
 is LOADED for real — a Google Fonts `<link>` (or `@font-face`) in
 `index.html`, per `$genex-ai-menu`'s genre font table; a display font that
 ships as a system-stack fallback (`Arial Black`, `Impact`) is the same bug in
 type.
 
-**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. 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),
-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 --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, 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
-matters MORE now that the concept carries a HUD: every widget in the mockup
-is a PROPOSAL, and a widget with no backing mechanic is cut before Stage 2 —
-mechanics come from the agreed game, never from the picture. Extra widgets
-the image invented are recorded in the plan message as "deferred from
-mockup" — never silently wired, never silently dropped. When
-the frame lands, diff it against the contract in one visible line — what
-does this game have that the frame doesn't show (enemies? arenas? the
-finish? the pickup)? Carry those requirements in words into every later
-prompt. Where the frame contradicts gameplay, gameplay wins — never inherit
-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 question
-with 2–3 concrete directions, each naming its palette + font pair — using
-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
-are examples, not defaults. Do not default to neon/cyberpunk/synthwave — or
-any other single register — unless the concept calls for it.
-
-**6. Close the gate out loud — a fixed-format plan message.** Post this
-message in chat, translated to the user's language, filling every line —
-this exact structure, not a paraphrase (the scaffold's keep-it-short talk
-rule explicitly does not apply to this one message):
+**3. Never stall the build on art.** Scaffold, boot wiring, the core loop,
+and the gameplay-logic modules keep moving in parallel whatever the UI is
+doing — and the core asset set (hero model, ground texture, skybox, sfx) is
+prompted from the game IDEA, so it can launch up front behind placeholders.
+Nothing ready to build waits on an art answer: decide, say the decision in
+one line, keep going.
 
-```
-UI plan
-• Screens: <list with tiers — loader / menu / pause (Esc) / win/lose / …>
-• 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>
-• 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">
-```
+**4. Ask only when genuinely ambiguous.** If the game's premise pins the mood
+(a "gothic horror dungeon crawler" pins it), decide and state it in one 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 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.
 
-A message missing any line means the gate did not run — go back and run it.
+**5. Style follows THIS game.** The examples in every Genex skill are
+examples, not defaults. Do not default to neon/cyberpunk/synthwave — or any
+other single register — unless the game calls for it.
 
 ## The tier ladder
 
-- **Tier 1 — instant baseline, every game.** Everything in this skill: planned
-  screens, shared brief, branded loader, animated CSS menu with keyboard
-  navigation, phase transitions, UI sounds, vignette. Zero generations — the
-  game is playable immediately.
-- **Tier 2 — the production UI, generated, async — mandatory, not an upsell.**
-  The sprite HUD (`$genex-ai-hud`) for EVERY game, the cinematic menu
-  video (`$genex-ai-menu`) whenever the menu decision is yes (the default for
-  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 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
-  exit: the user explicitly declines them — on their own initiative; never
-  solicit the decline by presenting these as optional, slow, or costly).
-  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 — 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 1 — the interface you build, zero generations.** Everything in this
+  skill: the planned screens, the shared brief, a branded loader, an animated
+  CSS menu with keyboard navigation, phase transitions, UI sounds, vignette.
+  Finished to this skill's readability, hierarchy, and motion rules, a
+  restrained CSS interface is a real, finished HUD — not a placeholder, not a
+  step toward something else. Plenty of games — anything spare, modern,
+  systems-y, minimal — are done here and better for it.
+- **Tier 2 — generated UI art, async, when the style asks for it.** The sprite
+  HUD (`$genex-ai-hud`), the cinematic menu video (`$genex-ai-menu`), and the
+  generated **logotype** — one `--transparent` wordmark in the brief's display
+  register (`$genex-ai-menu`'s logotype step). Reach for this lane when the
+  game's own style genuinely wants drawn chrome — ornate, painterly, comic,
+  hand-made — or when the player asks for HUD art. It is
+  **element-addressable**: generating ONE thing you decided the game needs — a
+  frame, a mask, an icon, a wordmark, a menu backdrop, a menu video — is a
+  normal, complete use of it, never a half-run pipeline. Enqueue `--no-wait`,
+  keep building, pick results up with `npx genex wait <id>`, and swap them in
+  as they land; while something is in flight, its id lives in DESIGN.md so a
+  compaction can pick it back up. Tier 2 never blocks a playable v0 — and
+  never park what landed: run `npx genex wait` on every enqueued ID before any
+  publish and before the final handoff of a session. When you show the user a
+  generated image, open it and paste the link (`npx genex wait <id> --open`,
+  or generate with `--open`) — a bare URL in a terminal is invisible, and "do
+  you like it?" with no picture in front of them is how that exchange fails.
+  Whatever you do generate gets its quality steps IN FULL — extraction, masks,
+  wiring, `npx genex ui audit`; judgment decides whether art is generated, it
+  never loosens how well it's done.
 - **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.
+  after the player has seen the interface working; build on request.
 
 ## Architecture: DOM overlay by default
 
@@ -357,12 +266,11 @@ black reads as a broken page. The branded version costs nothing:
 
 - **Background:** the menu's still frame — when the game has a cinematic menu,
   that image exists BEFORE the video does; show it dimmed
-  (`filter: brightness(0.6)`) behind the progress. Menu-less game: one
-  `npx genex image` key-art call in the house style, enqueued first thing.
-  Until the image arrives, the flat darkest hue from the style brief — a
-  placeholder with the same status as the placeholder CSS HUD: a loader
-  still without its key-art/menu-frame background at publish or session
-  handoff is the same failure.
+  (`filter: brightness(0.6)`) behind the progress. Otherwise, something
+  composed from the brief: an `npx genex image` key-art call in the house
+  style, or a CSS backdrop built from the brief's hues (a gradient field, the
+  logotype, a sliver of the game's own shapes). Flat black with a percentage
+  over it is the thing to avoid.
 - **Progress:** a thin bar styled from the brief (its accent hue), driven by
   real asset counts — never an indeterminate spinner alone.
 - **Reveal:** when ready, fade the loader out (400–600 ms) into the menu or
@@ -494,43 +402,39 @@ timer in the game WILL drift apart). Buttons and menu keys emit the same
 intents the gameplay input path uses — a "Restart" button and the R key must
 run identical code.
 
-The generated layer is the default, not a reward: every game's HUD is built
-from a generated sprite set (`$genex-ai-hud`), and a cinematic menu (looping
-video backdrop behind the buttons, `$genex-ai-menu`) backs every game whose
-menu decision is yes. Both slot into this exact `#ui` + `data-phase`
-architecture and consume the shared style brief.
+That holds whichever tier the interface is drawn in. When a game does take the
+generated layer — a sprite HUD (`$genex-ai-hud`), a cinematic menu with a
+looping video backdrop behind the buttons (`$genex-ai-menu`) — it slots into
+this exact `#ui` + `data-phase` architecture and consumes the shared style
+brief. Generated chrome changes how a widget LOOKS; it never changes where the
+widget gets its numbers.
 
 ## Failure modes to catch before the player does
 
-- No UI plan: screens invented one at a time, menu and HUD styled in two
-  different worlds.
-- A separate UI-free concept frame generated before the HUD mockup — the
-  concept IS the Stage-1 mockup, one generation; a second scene image for
-  "the concept" is a wasted spend and a style-drift risk.
-- The concept/mockup fed to `genex video --frame` — it has a HUD baked in;
-  the UI-free menu still is the ONLY valid frame input (`$genex-ai-menu`).
-- HUD sprites never enqueued at the gate — the placeholder CSS shipped as the
-  final HUD.
+- No screen inventory: screens invented one at a time, menu and HUD styled in
+  two different worlds.
+- A HUD-bearing image fed to `genex video --frame` — a frame with UI baked
+  into it yields a menu backdrop with UI baked into it; the UI-free menu still
+  is the ONLY valid frame input (`$genex-ai-menu`).
+- The build stalled waiting on art — scaffold, core loop, and logic modules
+  keep moving in parallel while anything generated is in flight.
 - No pause screen, or a pause that isn't bound to Escape.
 - The OS arrow parked over the action for the whole session in a keyboard-driven
   game (the cursor is either a gameplay tool or locked away — see the cursor
   section).
 - A style brief whose fonts were never actually loaded (a system-stack display
   font at runtime).
-- A micro-element (reticle, cue, toast, damage number) left as default CSS
-  while the panels got the art treatment.
+- A micro-element (reticle, cue, toast, damage number) left at browser
+  defaults while the panels got the full treatment — one interface, one level
+  of finish.
 - A generic stat dashboard (rows of labels + numbers) instead of a designed
   HUD — pick the 2–3 numbers that matter and style them by hierarchy.
 - Hard-cut phase swaps, a menu whose elements just appear, numbers that
   teleport.
 - A silent menu; a bare "Loading…" over black.
-- 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.
+- Generated UI art enqueued and then left on the shelf — a landed sprite sheet
+  that never got extracted, masked, and wired is worse than never running the
+  lane at all.
 - 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-game-ui/references/style-capsules.md

@@ -107,7 +107,7 @@ their ONE established HUD use, the masked-fill progress reveal.
   canvas texture on PLATES (not full-screen).
 - A display face with calligraphic character; body stays clean for
   readability.
-- Palette lifted from the scene's own key art — sample it, don't invent a
-  second palette.
+- Palette lifted from the game's own world — sample the scene (or its key art,
+  where the game has some), don't invent a second palette.
 - Menu lean: **left rail** or **diegetic corner** over the painted vista;
   brushwork logotype; bare text with calligraphic display face.