@genex-ai/cli-demo 0.55.0-dev.125 → 0.57.0-dev.129

package/README.md

@@ -141,7 +141,7 @@ one call (`image-main` + `image-alt-N` URLs) — pick the best instead of re-rol
 `genex character "<prompt>"` runs a controller-ready Meshy workflow through the
 same authenticated credit, BullMQ/Redis, and R2 generation pipeline. It defaults
 to a Meshy 6 textured A-pose humanoid with browser-oriented remeshing, rigging, and the
-validated idle/walk/run/jump pack. `--animation <id-or-query>` is repeatable;
+preview-reviewed neutral-v2 idle/walk/run/crouch/jump pack. `--animation <id-or-query>` is repeatable;
 `--height`, `--polycount`, `--no-controller-pack`, and `--no-wait` adjust the
 request. The CLI prints an atomic component quote before enqueueing.
 

package/dist/index.js

@@ -3239,6 +3239,19 @@ async function installMeshyCharacterManifest(args) {
 `
   );
   args.log.dim(`  public/assets/meshy-character.json (${args.characterId}, current revision)`);
+  const pack = manifest.controllerPack;
+  if (typeof pack?.key === "string" && typeof pack.version === "number") {
+    args.log.success(`Meshy controller pack ${pack.key} v${pack.version}`);
+  } else {
+    args.log.warn("Legacy Meshy manifest \u2014 regenerate the character for the preview-reviewed neutral-v2 locomotion pack.");
+  }
+  const actionIds = (manifest.clips ?? []).map((clip) => clip.actionId).filter((actionId) => typeof actionId === "number");
+  args.log.dim(`  installed action ids: ${actionIds.length > 0 ? actionIds.join(", ") : "none"}`);
+  const slots = Object.keys(manifest.locomotion?.bindings ?? manifest.locomotion?.slots ?? {}).sort();
+  args.log.dim(`  locomotion slots: ${slots.length > 0 ? slots.join(", ") : "none"}`);
+  const crouchCovered = slots.includes("crouch.idle") && slots.includes("crouch.forward");
+  if (crouchCovered) args.log.success("Visual crouch coverage: idle + move");
+  else args.log.warn("Visual crouch coverage is incomplete; physics crouch may fall back to a standing pose.");
 }
 async function installOwnerAvatar(args) {
   const { root, srcDir, apiUrl, token, log } = args;
@@ -12129,7 +12142,42 @@ var CURATED = {
   [-2]: { loop: true, motionPolicy: "controller-loop", controllerSlots: ["walk.forward"] },
   [-1]: { loop: true, motionPolicy: "controller-loop", controllerSlots: ["run.forward"] },
   [0]: { loop: true, motionPolicy: "controller-loop", controllerSlots: ["idle.default"] },
-  [466]: { loop: false, motionPolicy: "anchored-action", controllerSlots: ["jump.full"] }
+  [243]: {
+    loop: true,
+    motionPolicy: "controller-loop",
+    controllerSlots: ["idle.default"],
+    reviewStatus: "preview-reviewed"
+  },
+  [466]: {
+    loop: false,
+    motionPolicy: "anchored-action",
+    controllerSlots: ["jump.full"],
+    reviewStatus: "preview-reviewed"
+  },
+  [613]: {
+    loop: true,
+    motionPolicy: "controller-loop",
+    controllerSlots: ["walk.forward"],
+    reviewStatus: "preview-reviewed"
+  },
+  [616]: {
+    loop: true,
+    motionPolicy: "controller-loop",
+    controllerSlots: ["crouch.forward"],
+    reviewStatus: "preview-reviewed"
+  },
+  [658]: {
+    loop: true,
+    motionPolicy: "controller-loop",
+    controllerSlots: [],
+    reviewStatus: "rejected"
+  },
+  [659]: {
+    loop: true,
+    motionPolicy: "controller-loop",
+    controllerSlots: ["run.forward"],
+    reviewStatus: "preview-reviewed"
+  }
 };
 var LOOP_SUBCATEGORIES = /* @__PURE__ */ new Set(["Idle", "Walking", "Running", "CrouchWalking", "Swimming"]);
 var CHOREOGRAPHY_SUBCATEGORIES = /* @__PURE__ */ new Set([
@@ -12373,6 +12421,12 @@ async function runCharacter(opts) {
   }
   log.plain(c.bold("Character quote"));
   log.plain(`  ${price.credits} Genex credits = base ${price.baseCredits} + actions ${price.animationCredits}`);
+  if (price.controllerPackKey) {
+    log.plain(
+      `  controller pack ${c.cyan(price.controllerPackKey)} \xB7 provider actions ${(price.controllerActionIds ?? []).join(", ")}`
+    );
+  }
+  log.dim(`  ${price.actionsGenerated} Meshy animation task${price.actionsGenerated === 1 ? "" : "s"} in this request.`);
   log.plain("");
   await runGenerate("character", {
     ...opts,
@@ -12490,7 +12544,7 @@ async function runAnimationsSearch(opts) {
     ];
     log.plain(`  ${c.cyan(String(result.actionId))}  ${c.bold(result.name)}  ${c.dim(result.key)}`);
     log.dim(
-      `      ${result.motionPolicy}${result.inPlace ? " \xB7 InPlace" : ""}${slots}${requirements.length > 0 ? ` \xB7 needs ${requirements.join(", ")}` : ""}`
+      `      ${result.motionPolicy}${result.inPlace ? " \xB7 InPlace" : ""}${slots}${requirements.length > 0 ? ` \xB7 needs ${requirements.join(", ")}` : ""} \xB7 ${result.reviewStatus}`
     );
     log.dim(`      preview ${result.previewUrl} \xB7 estimated additional cost ${result.estimatedCredits} credits`);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@genex-ai/cli-demo",
-  "version": "0.55.0-dev.125",
+  "version": "0.57.0-dev.129",
   "description": "Set up your ~/.claude workspace, authorize, create a game project, generate AI assets, and publish (genex CLI).",
   "type": "module",
   "bin": {

package/templates/controllers/character/meshy/meshy-loader.ts

@@ -9,12 +9,21 @@ export type MeshyMotionPolicy =
   | "planar-root-action"
   | "choreography";
 
+export type MeshyLocomotionBindingMode = "loop" | "one-shot" | "pose";
+
+export interface MeshyLocomotionBinding {
+  clip: string;
+  mode: MeshyLocomotionBindingMode;
+  phase?: number;
+}
+
 export interface MeshyCharacterManifest {
   schema: 1;
   characterId: string;
   revision: number;
   manifestVersion: number;
   rig: "meshy-biped";
+  controllerPack?: { key: string; version: number };
   model: {
     url: string;
     heightMeters: number | null;
@@ -37,6 +46,7 @@ export interface MeshyCharacterManifest {
   }>;
   locomotion: {
     slots: Record<string, string>;
+    bindings?: Record<string, MeshyLocomotionBinding>;
     fallbacks: Record<string, string>;
     nominalSpeed?: Partial<Record<"walk" | "run" | "crouch", number>>;
     playbackRate: { min: number; max: number };
@@ -77,6 +87,57 @@ function compatibleTracks(model: THREE.Object3D, clips: THREE.AnimationClip[]):
   }));
 }
 
+type TrackConstructor = new (
+  name: string,
+  times: ArrayLike<number>,
+  values: ArrayLike<number>,
+  interpolation?: number,
+) => THREE.KeyframeTrack;
+
+/** Materialize one reviewed frame as an independent mixer clip for crouch-idle. */
+export function createPoseClip(source: THREE.AnimationClip, name: string, phase = 0): THREE.AnimationClip {
+  const sampleTime = Math.max(0, Math.min(1, phase)) * Math.max(0, source.duration);
+  const tracks = source.tracks.map((track) => {
+    const valueSize = track.getValueSize();
+    const sampled = new Float32Array(valueSize);
+    const interpolant = (track as THREE.KeyframeTrack & {
+      createInterpolant(result: Float32Array): { evaluate(time: number): ArrayLike<number> };
+    }).createInterpolant(sampled);
+    interpolant.evaluate(sampleTime);
+    const Track = track.constructor as TrackConstructor;
+    return new Track(track.name, [0], sampled, track.getInterpolation());
+  });
+  // A non-zero duration keeps the static pose well-defined for looped mixer actions.
+  return new THREE.AnimationClip(name, 1, tracks);
+}
+
+export function resolveMeshyLocomotion(
+  manifest: MeshyCharacterManifest,
+  sourceClips: readonly THREE.AnimationClip[],
+): { clips: THREE.AnimationClip[]; slots: Record<string, string>; missingBindings: string[] } {
+  const clips = [...sourceClips];
+  const slots = { ...manifest.locomotion.slots };
+  const missingBindings: string[] = [];
+  for (const [slot, binding] of Object.entries(manifest.locomotion.bindings ?? {})) {
+    const source = clips.find((clip) => clip.name === binding.clip);
+    if (!source) {
+      missingBindings.push(slot);
+      continue;
+    }
+    if (binding.mode === "pose") {
+      const poseName = `${binding.clip}__${slot.replaceAll(".", "_")}__pose`;
+      clips.push(createPoseClip(source, poseName, binding.phase));
+      slots[slot] = poseName;
+    } else {
+      slots[slot] = binding.clip;
+    }
+  }
+  for (const [slot, fallback] of Object.entries(manifest.locomotion.fallbacks)) {
+    if (!slots[slot] && slots[fallback]) slots[slot] = slots[fallback];
+  }
+  return { clips, slots, missingBindings };
+}
+
 export async function loadMeshyCharacter(manifestUrl: string): Promise<MeshyCharacter> {
   const response = await fetch(manifestUrl);
   if (!response.ok) throw new Error(`[meshy-character] ${manifestUrl} returned HTTP ${response.status}`);
@@ -106,18 +167,18 @@ export async function loadMeshyCharacter(manifestUrl: string): Promise<MeshyChar
     if (compatible.length === 1) compatible[0]!.name = item.entry.key;
     clips.push(...compatible);
   }
-  const slots = { ...manifest.locomotion.slots };
-  for (const [slot, fallback] of Object.entries(manifest.locomotion.fallbacks)) {
-    if (!slots[slot] && slots[fallback]) slots[slot] = slots[fallback];
+  const locomotion = resolveMeshyLocomotion(manifest, clips);
+  for (const slot of locomotion.missingBindings) {
+    console.warn(`[meshy-character] locomotion binding ${slot} references a clip that did not load.`);
   }
   return {
     kind: "meshy-native",
     scene: base.scene,
-    clips,
+    clips: locomotion.clips,
     manifest,
     rigSignature: manifest.model.skeletonSignature,
     locomotionProfile: {
-      slots,
+      slots: locomotion.slots,
       nominalSpeed: manifest.locomotion.nominalSpeed,
       playbackRate: manifest.locomotion.playbackRate,
     },

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

@@ -17,7 +17,8 @@ npx genex character "stylized desert courier, practical layered clothing"
 ```
 
 The default request uses Meshy 6 to generate and texture an A-pose humanoid,
-remeshes and rigs it, adds the validated idle/walk/run/jump controller pack,
+remeshes and rigs it, adds the preview-reviewed neutral-v2
+idle/walk/run/crouch/jump controller pack,
 and stores every successful model
 and clip at permanent Genex asset URLs. It prints the complete Genex-credit
 quote before enqueueing. The Meshy API key remains server-side; never ask the
@@ -35,6 +36,12 @@ npx genex wait <generation-id>
 omits the default locomotion pack. `--no-wait` returns a generation id for
 `genex wait`; it does not create a second paid request.
 
+Before handoff, capture idle, walk, run, crouch-idle, crouch-move, and jump.
+Inspect shoulders, elbows, wrists, and hands as well as the feet. Reject
+shrugging palms-up poses, permanently raised elbows, or a gait whose
+upper-body style contradicts the requested character. “No T-pose” is not
+an animation-quality check.
+
 ## Search first; use action IDs
 
 ```bash

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

@@ -205,6 +205,11 @@ jumping. `crouchMode: "hold"` makes it hold-to-crouch;
 `character.setCrouch(bool)` and `character.crouchActive` are the programmatic
 hooks (that's also how a touch button wires in — see Mobile below).
 
+Press every control that the HUD or handoff advertises. For Meshy characters,
+crouch passes only when both the capsule behavior and a visibly crouched pose
+are confirmed. Capture crouch-idle and crouch-move separately; a standing
+animation over a shortened capsule is not working crouch.
+
 ## Mobile: TouchJoystick + VirtualButton (wire by default)
 
 **Wire these whenever this controller is installed — not only when asked.**

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

@@ -44,7 +44,11 @@ everything twice.
    sign-in gate.
 2. Press each documented control once (keys, pointer); assert a **visible
    response** to every one — the player moves, the camera turns, the button
-   fires.
+   fires. For an animated character, capture idle, walk, run, crouch-idle,
+   crouch-move, and jump. Inspect shoulders, elbows, wrists, and hands as well
+   as the feet: a fully bound non-T-pose can still be stylistically broken.
+   For Meshy characters, crouch passes only when the capsule behavior and a
+   visibly crouched pose both respond.
 3. Capture one screenshot of live gameplay — of the **game**, not a sign-in
    gate or loading screen. A capture of the SDK's "Sign in to play" overlay is
    NOT gameplay evidence. Evidence captured in local test mode must be labeled