@genex-ai/cli-demo 0.12.1 → 0.14.2

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

@@ -0,0 +1,198 @@
+# Wiring the character controller
+
+The full path from an empty scene to a playable character:
+world → `CharacterController` → `FollowCamera` → `KeyboardInput` /
+`TouchJoystick` → `CharacterAnimations`. Every class and option name below is
+the vendored code's real API — copy from here, not from memory.
+
+## 1. Physics world
+
+```ts
+import { PhysicsWorld } from "./controllers/shared/physics-world.ts";
+
+const physics = await PhysicsWorld.create();      // awaits RAPIER.init() (embedded WASM)
+const world = physics.world;                      // the raw Rapier world controllers consume
+```
+
+Nothing may construct any RAPIER object before `create()` resolves. Options if
+you need them: `gravity` (default `[0, -9.81, 0]`), `timeStep` (default
+`1/60`), `maxDelta`, `interpolate`. `physics.paused` and `physics.timeScale`
+give you pause and slow motion for free.
+
+## 2. Level colliders
+
+Every walkable surface needs a rigid body + collider. For authored boxes:
+
+```ts
+import { cuboidCollider } from "./controllers/shared/colliders.ts";
+
+const ground = new THREE.Mesh(new THREE.BoxGeometry(90, 0.5, 90), groundMat);
+scene.add(ground);
+const groundBody = physics.createBody({ type: "fixed", position: [0, -0.25, 0] }, ground);
+cuboidCollider(world, groundBody, [45, 0.25, 45], { friction: 1 }); // HALF extents
+```
+
+For loaded GLB level pieces, `collidersFromObject(world, body, gltf.scene, "trimesh")`
+auto-generates colliders per mesh (`"hull"` for dynamic props from
+`$genex-ai-model`; `"trimesh"` only on static geometry). `cuboidCollider`
+takes **half** extents — do not halve twice.
+
+## 3. Character
+
+```ts
+import { CharacterController } from "./controllers/character/character-controller.ts";
+import { characterPresets } from "./controllers/character/presets.ts";
+
+const character = new CharacterController(world, camera, {
+  ...characterPresets["default"].options,
+  position: { x: 0, y: 2, z: 0 },
+  userData: { controller: { excludeVehicleRay: true } },
+});
+scene.add(character.root);
+physics.registerBody(character.body, character.root);
+```
+
+- The constructor creates the dynamic body + capsule collider immediately.
+- `character.root` is the visual anchor; `registerBody` makes it follow the
+  body with interpolation. Register scene-root-level groups and add them to the
+  scene **first** — `registerBody` captures the parent's world matrix once and
+  never refreshes it.
+- `userData: { controller: { excludeVehicleRay: true } }` keeps car wheels
+  from treating the on-foot player as drivable ground. Related keys (set on
+  OTHER bodies): `excludeRay` (ignored by all ground queries),
+  `excludeCharacterRay` (ignored by the character's ground query only).
+- The camera argument is how movement becomes camera-relative ("forward" = away
+  from camera). Pass the same camera the `FollowCamera` drives.
+
+### Place the model so its feet touch the ground
+
+The capsule floats: in root space the ground is at
+`-(capsuleHalfHeight + capsuleRadius + floatHeight)` — **-0.8** with the
+defaults (0.3 + 0.3 + 0.2). Normalize any loaded model to ~1.35 units tall and
+drop its bounding-box bottom to that line:
+
+```ts
+const bbox = new THREE.Box3().setFromObject(model);
+const scale = 1.35 / Math.max(bbox.max.y - bbox.min.y, 1e-3);
+model.scale.setScalar(scale);
+model.position.y = -0.8 - bbox.min.y * scale;
+character.root.add(model);
+```
+
+A model hovering above the floor or knee-deep in it means this offset is wrong
+— it is the single most common wiring bug.
+
+## 4. Input
+
+```ts
+import { KeyboardInput } from "./controllers/character/keyboard-input.ts";
+
+const kb = new KeyboardInput(); // WASD/arrows move, Shift run, Space jump, F interact
+```
+
+Event-driven — nothing to poll per frame. Read `kb.getCharacterMovement()`
+inside the before-step callback and pass the **complete** intent object every
+time: the controller merges defined fields, so a stale partial would leave old
+`true`s behind. Merge touch controls caller-side (see the SKILL's mobile
+section). `kb.onInteract(cb)` is the rising-edge F-key hook (for enter/exit).
+It already clears all keys on window blur / tab hide, so no stuck-key handling
+is needed.
+
+## 5. Follow camera
+
+```ts
+import { FollowCamera } from "./controllers/character/follow-camera.ts";
+
+const followCam = new FollowCamera(camera, {
+  domElement: renderer.domElement,
+  colliderMeshes: staticWallMeshes,
+});
+```
+
+Drag orbits, wheel/pinch zooms, and rays pull the camera in front of walls.
+Rules that matter:
+
+- `colliderMeshes` takes static **leaf** meshes only (the ray test is
+  non-recursive) and must never include the character or vehicle meshes — the
+  rays start at the character's head and would hit them every frame. The array
+  is public — mutate it after level loads.
+- `minDistance` defaults to 0.02, so zooming all the way in is effectively
+  first-person; clamp with `minDistance`/`maxDistance` for your scale.
+- Feel: `smoothTime` (0.05 snappy → 0.25 cinematic, default 0.1),
+  `initialDistance` (default 4), `initialAzimuthAngle` (default `Math.PI` —
+  camera starts behind a +Z-facing character).
+- v1 limits (by design): no pointer-lock mode, no truck/pan, and the orbit
+  space assumes the up axis stays roughly world +Y — far-from-Y custom gravity
+  will misbehave.
+
+## 6. The loop — exact order
+
+Per fixed **substep** (inside `physics.onBeforeStep`), in this order:
+
+1. Drive moving platforms (`setNextKinematicTranslation` / `setNextKinematicRotation`).
+2. `EnterExitManager.update(dt)` — only if vehicles exist (vehicle skill).
+3. `character.setMovement(...)` then `character.update()` — skip while
+   `character.isParked`.
+4. (Vehicle/drone `update()` calls, if any.)
+5. `world.step()` happens automatically right after your callback returns.
+
+Per **render** frame (inside `renderer.setAnimationLoop`), in this order:
+
+```ts
+const delta = clock.getDelta();
+physics.step(delta);                               // 1. fixed substeps + mesh sync
+
+pivot.copy(character.currPos).addScaledVector(character.bodyYAxis, 0.5);
+followCam.moveTo(pivot.x, pivot.y, pivot.z, true); // 2. feed the camera
+followCam.setUp(character.upAxis);
+if (physics.stepsLastFrame > 0 && character.isOnPlatform) {
+  followCam.applyPlatformTurn(character.turnOnYQuat);
+}
+followCam.update(delta);                           // 3. damp + place the camera
+
+anims.update(character, delta);                    // 4. animations (render delta)
+renderer.render(scene, camera);                    // 5. draw
+```
+
+Non-negotiables:
+
+- `update()` takes an optional dt **and ignores it** — all controller time
+  terms use the fixed `world.timestep`. Never call controller updates from the
+  render loop directly.
+- `applyPlatformTurn` consumes a per-physics-step yaw delta: gate it on
+  `physics.stepsLastFrame > 0`, or high-refresh displays re-apply a stale delta
+  and the camera over-rotates on platforms.
+- Camera and animation updates take the **render** delta, never
+  `physics.timeStep`.
+
+## 7. Reading state (for game logic)
+
+All getters are live internal objects — `.clone()` if you keep them:
+`currPos`, `currQuat`, `currLinVel`, `isOnGround`, `isFalling`, `isMoving`,
+`isOnPlatform`, `moveSpeed`, `verticalSpeed`, `runActive`, `jumpActive`,
+`slopeAngle`, `actualSlopeAngle`, `standCollider` (the rigid body under the
+character), `standPoint`, `standNormal`, `upAxis`, `bodyZAxis` (facing).
+Useful methods beyond `setMovement`: `setLockForward(true)` for strafe mode,
+`setGroundDetection("rayCast" | "shapeCast")`, `park()` / `unpark(pos, euler)`
+for vehicle boarding, `syncRoot()` if you skip `registerBody`.
+
+## 8. Debug and teardown
+
+- `physics.enableDebug(scene)` draws every collider as wireframe lines
+  (disable in shipped games); `{ debug: true }` + a `debugScene` constructor
+  arg adds per-controller indicators.
+- Teardown: `character.dispose()`, `kb.dispose()`, `followCam.dispose()`,
+  joystick/button `.dispose()`, then `physics.dispose()` last.
+
+## Troubleshooting
+
+- **Character slides down gentle ramps or climbs cliffs** — check
+  `slopeMaxAngle` (default 72°); see the tuning reference.
+- **Stuck bouncing at spawn** — spawn `position.y` too low; the capsule center
+  must start above `capsuleHalfHeight + capsuleRadius + floatHeight`.
+- **Model drifts away from the capsule** — the registered root's parent moved
+  or scaled after `registerBody`; register scene-root groups only.
+- **Movement ignores the camera** — you passed a different camera to the
+  controller than the one being rendered.
+- **`using deprecated parameters for the initialization function` in the
+  console** — harmless one-time Rapier WASM-loader message; ignore it.

package/templates/skills/genex-threejs-physics-rapier/SKILL.md

@@ -0,0 +1,128 @@
+---
+name: genex-threejs-physics-rapier
+description: Set up Rapier physics for Genex Three.js games with the vendored PhysicsWorld glue — async WASM init, fixed-timestep world, body-to-mesh sync, collision events — and pick the right collider per asset (cuboid, hull, trimesh, including genex model GLBs). Use whenever anything falls, collides, gets pushed, or stands on moving ground; load before writing any physics code.
+---
+
+# Genex Three.js Physics (Rapier)
+
+Genex games run physics on Rapier (`@dimforge/rapier3d-compat`) through a small
+vendored glue layer: `PhysicsWorld` owns the world, the fixed-timestep loop,
+the rigid-body ↔ `Object3D` sync, and collision events; `shared/colliders.ts`
+turns meshes and GLBs into colliders. You do not install this from a skill —
+a CLI command drops the code into the game.
+
+## Get the code (one command, not hand-rolled)
+
+```bash
+npx genex controller character   # or car / drone — every kind installs shared/
+npm i @dimforge/rapier3d-compat
+```
+
+The command copies `src/controllers/shared/physics-world.ts`,
+`shared/colliders.ts`, and `shared/math.ts` into the game (plus the controller
+you picked). Even a game that only needs loose physics — falling crates, a
+rolling ball — should run it once for the `shared/` layer; existing files are
+never overwritten without `--force`.
+
+**Never hand-write character or vehicle physics.** A capsule you push around
+with raw impulses will clip slopes, stutter on stairs, and slide off moving
+platforms — this is the single most common way physics games go wrong. Tuned,
+tested controllers already exist: load `$genex-threejs-character-controller`
+for walking/running/jumping and `$genex-threejs-vehicle-controllers` for cars
+and drones, each installed by the same `npx genex controller` command.
+
+## Minimal working setup
+
+```ts
+import * as THREE from "three";
+import { PhysicsWorld } from "./controllers/shared/physics-world.ts";
+import { cuboidCollider } from "./controllers/shared/colliders.ts";
+
+const physics = await PhysicsWorld.create(); // awaits RAPIER.init() (embedded WASM)
+const world = physics.world;                 // the raw Rapier world
+
+// Static ground: a box whose top face is at y = 0.
+const ground = new THREE.Mesh(new THREE.BoxGeometry(100, 0.5, 100), groundMat);
+scene.add(ground);
+const groundBody = physics.createBody({ type: "fixed", position: [0, -0.25, 0] }, ground);
+cuboidCollider(world, groundBody, [50, 0.25, 50], { friction: 1 });
+
+// Dynamic crate: passing the mesh to createBody registers it — the mesh
+// follows the body automatically every frame, interpolated between steps.
+const crate = new THREE.Mesh(new THREE.BoxGeometry(1, 1, 1), crateMat);
+scene.add(crate);
+const crateBody = physics.createBody({ type: "dynamic", position: [0, 3, 0] }, crate);
+cuboidCollider(world, crateBody, [0.5, 0.5, 0.5], { friction: 0.6, density: 1 });
+
+// Anything that pushes bodies runs once per fixed substep, before the step:
+physics.onBeforeStep(() => {
+  // controller.update(), impulses, kinematic platform poses ...
+});
+
+const clock = new THREE.Clock();
+renderer.setAnimationLoop(() => {
+  physics.step(clock.getDelta()); // fixed substeps + mesh sync + events
+  // camera follow, animation mixers — render-delta work stays OUT here
+  renderer.render(scene, camera);
+});
+```
+
+Note `cuboidCollider` takes **half** extents: `[0.5, 0.5, 0.5]` is a 1×1×1 box.
+
+## The update ordering contract
+
+Physics code never sees the render framerate. Keep this order or controllers
+misbehave in ways that look like tuning problems:
+
+1. **Inside `physics.onBeforeStep(...)`** — runs once per fixed substep, in
+   this order: kinematic platform poses (`setNextKinematicTranslation` /
+   `setNextKinematicRotation`), then `EnterExitManager.update(dt)` if the game
+   has enter/exit vehicles, then each controller's `update()`. Controllers
+   ignore any dt argument and read `world.timestep` internally — never feed
+   them the render delta.
+2. **`physics.step(delta)`** — once per `requestAnimationFrame`, with the
+   render clock delta in **seconds**. It runs zero or more fixed substeps,
+   syncs registered meshes (interpolated), and drains collision events.
+3. **After `step`** — cameras, animation mixers, HUD: render-delta work. Gate
+   once-per-physics-step camera corrections on `physics.stepsLastFrame > 0`.
+
+Read [references/physics-setup.md](references/physics-setup.md) for world
+options, the body registry and its caveats, kinematic platforms, collision and
+sensor events, sleeping bodies, CCD/tunneling, pause/slow-mo, and debug
+rendering.
+
+Read [references/colliders-from-assets.md](references/colliders-from-assets.md)
+for the collider decision table per asset type — `genex model` GLBs, level
+geometry, primitives — hull vs trimesh tradeoffs, and the scale pitfalls.
+
+## Benign boot warning — do not chase it
+
+`@dimforge/rapier3d-compat` 0.19.3 logs once at startup:
+
+```text
+using deprecated parameters for the initialization function; pass a single object instead
+```
+
+This comes from the library's own embedded WASM loader, cannot be fixed from
+game code, and is harmless. Ignore it; do not refactor init code trying to
+silence it.
+
+## Failure conditions
+
+- physics stepped with the raw render delta instead of `physics.step`'s fixed
+  accumulator (speed varies with framerate);
+- a controller updated outside `onBeforeStep`, or fed the render delta;
+- a dynamic body repositioned with `setTranslation` every frame instead of
+  being kinematic;
+- a trimesh collider on a fast dynamic body (falls through the floor);
+- colliders built from a model whose scale changes afterwards;
+- a mesh registered to a body after its parent moved or scaled (silent desync);
+- hand-written character/vehicle physics instead of `npx genex controller`.
+
+## Routing boundary
+
+Player movement, jumping, slopes, and animation state belong to
+`$genex-threejs-character-controller`. Cars, drones, and enter/exit flow belong
+to `$genex-threejs-vehicle-controllers`. Chase/orbit camera design beyond the
+bundled follow camera is `$genex-threejs-camera-direction`. Meshes for props
+come from `$genex-ai-model`; this skill only decides how they collide.

package/templates/skills/genex-threejs-physics-rapier/references/colliders-from-assets.md

@@ -0,0 +1,202 @@
+# Colliders from assets
+
+Everything here documents `src/controllers/shared/colliders.ts` as installed
+by `npx genex controller`. All helpers assume `PhysicsWorld.create()` has
+already resolved — constructing a collider before WASM init throws.
+
+## Contents
+
+- Decision table: which collider for which asset
+- Explicit primitive helpers
+- Auto-colliders from a GLB scene
+- Hull vs trimesh
+- Scale pitfalls
+- Collider options
+- Sensors
+- End-to-end: a genex model prop
+
+## Decision table: which collider for which asset
+
+| Asset | Collider | Why |
+| --- | --- | --- |
+| ground, walls, crates, platforms (box-shaped) | `cuboidCollider` | cheapest, exact for boxes |
+| dynamic prop from `npx genex model` (barrel, rock, chair) | `convexHullColliderFromMesh` (or `collidersFromObject(..., "hull")` for multi-mesh GLBs) | tight fit, still convex/fast/solid |
+| static level GLB (terrain piece, building interior, track) | `trimeshColliderFromMesh` per mesh | exact triangles; safe because it never moves |
+| ball-shaped things | `ballCollider` | exact sphere |
+| tall dynamic props, posts | `capsuleCollider` / `cylinderCollider` | stable standing shapes |
+| pickups, triggers, zones | any shape + `{ sensor: true, mass: 0 }` | overlap events, no contact forces |
+| the player, cars, drones | none of the above — `npx genex controller` | controllers own their collider recipes |
+
+## Explicit primitive helpers
+
+```ts
+import {
+  cuboidCollider,
+  ballCollider,
+  capsuleCollider,
+  cylinderCollider,
+} from "./controllers/shared/colliders.ts";
+
+cuboidCollider(world, body, [1, 0.4, 2.4], { friction: 1 }); // HALF extents: 2 x 0.8 x 4.8 box
+ballCollider(world, body, 0.5);
+capsuleCollider(world, body, 0.3, 0.3);   // (halfHeight, radius)
+cylinderCollider(world, body, 0.15, 3);   // (halfHeight, radius)
+```
+
+Two classic mistakes, called out because they are silent:
+
+- **Cuboid takes HALF extents.** A `[1, 0.4, 2.4]` collider is a 2 × 0.8 × 4.8
+  box. Do not halve twice.
+- **Capsule/cylinder arg order is `(halfHeight, radius)`** — the REVERSE of
+  `THREE.CapsuleGeometry(radius, length)` — and the capsule's `halfHeight`
+  covers the cylindrical section only: total height is
+  `2 * halfHeight + 2 * radius`, so `(0.3, 0.3)` is 1.2 units tall.
+
+All helpers return the created `RAPIER.Collider` and accept a `ColliderOptions`
+last argument (below), including `position`/`rotation` relative to the body.
+
+## Auto-colliders from a GLB scene
+
+`collidersFromObject` walks every visible mesh under an object and creates one
+collider per mesh — the batteries-included path for GLBs:
+
+```ts
+import { collidersFromObject } from "./controllers/shared/colliders.ts";
+
+const gltf = await loader.loadAsync("./assets/models/weathered-wooden-barrel.glb");
+const model = gltf.scene;
+scene.add(model);
+
+const body = physics.createBody({ type: "dynamic", position: [0, 2, 0] }, model);
+collidersFromObject(world, body, model, "hull", { friction: 0.7, density: 400 });
+```
+
+- Shapes: `"cuboid"` (bounding box per mesh — cheapest), `"ball"` (bounding
+  sphere), `"hull"` (convex hull per mesh — the default choice for `genex
+  model` props), `"trimesh"` (exact triangles — static geometry only).
+- `object3d` must be the SAME object registered to the body (their frames must
+  coincide); call it right after `createBody`, before the first step.
+- Hidden meshes are skipped unless you pass `includeInvisible: true` in the
+  options.
+- It returns the array of created colliders, so you can attach events or
+  retune later.
+
+For a single mesh you can target directly, the explicit forms skip the
+traversal:
+
+```ts
+import {
+  convexHullColliderFromMesh,
+  trimeshColliderFromMesh,
+} from "./controllers/shared/colliders.ts";
+
+convexHullColliderFromMesh(world, dynamicBody, propMesh, { density: 400 });
+trimeshColliderFromMesh(world, fixedBody, levelMesh, { friction: 1 });
+```
+
+Both bake the mesh's current world transform relative to the body, so the
+collider lands exactly where the mesh renders.
+
+## Hull vs trimesh
+
+| | Convex hull | Trimesh |
+| --- | --- | --- |
+| fit | shrink-wraps the mesh; concavities filled in (a mug loses its opening) | exact triangles, concavities preserved |
+| solidity | solid volume | **hollow shell** — a body starting inside it is stuck or falls through |
+| cost | cheap contacts | expensive contacts; scales with triangle count |
+| dynamic bodies | yes — the default for props | **never on fast dynamic bodies** — thin hollow triangles are the classic tunneling recipe |
+| static level geometry | fine but approximate | the right tool |
+
+When one hull is too crude for a concave prop, prefer either of these before
+reaching for a dynamic trimesh:
+
+- **Per-mesh hulls:** most multi-part GLBs already split into several meshes,
+  and `collidersFromObject(world, body, model, "hull")` gives one hull per
+  part — a compound of convex pieces approximates concavity well.
+- **A few hand-placed primitives:** two or three `cuboidCollider`s with
+  `position` offsets often beat any auto shape (this is how the bundled
+  vehicle chassis recipes work).
+
+`"hull"` can also fail outright on degenerate/coplanar geometry — the helper
+throws with the mesh name; fall back to `"cuboid"` for such meshes.
+
+## Scale pitfalls
+
+Colliders copy geometry **at creation time**; they do not track later
+transforms.
+
+- **Scale the model BEFORE creating colliders.** Normalize the GLB (e.g.
+  `model.scale.setScalar(targetHeight / bboxHeight)`) first, then create the
+  body and colliders. Changing `scale` afterwards resizes the render mesh
+  only — the collider keeps the old size.
+- **Put scale on the mesh, not on the registered root.** The auto-collider
+  path faithfully replicates an upstream quirk: the registered root's world
+  scale is double-counted in collider sizing, so a root scaled 2× produces
+  colliders 2× larger than the rendered meshes. Scaling child meshes (or the
+  GLB scene before registering a plain unscaled root) avoids the quirk
+  entirely.
+- **`"ball"` uses `scale.x` only** (same upstream quirk, replicated not
+  fixed) — a non-uniformly scaled sphere gets the wrong radius. Use `"hull"`
+  for squashed spheres.
+- **Verify visually.** `physics.enableDebug(scene)` draws every collider as a
+  wireframe — one glance catches every scale/offset mistake in this section.
+
+## Collider options
+
+`ColliderOptions`, accepted by every helper (and applied via
+`applyColliderOptions(collider, options)` if you retune at runtime):
+
+| Option | Notes |
+| --- | --- |
+| `friction` | negative values are legal and load-bearing — the bundled character capsule ships with `-0.5` because its traction is synthetic; do not clamp |
+| `restitution` | bounciness 0–1 |
+| `density` / `mass` | **mutually exclusive — picking both throws.** `density` is kg/m³ (water ≈ 1000, wood ≈ 400–700); `mass` is absolute kg |
+| `sensor` | overlap detection, no contact forces |
+| `position` / `rotation` | collider pose relative to its body (euler XYZ radians) |
+| `collisionGroups` / `solverGroups` | raw Rapier bitmasks |
+| `contactSkin` | extra contact thickness — trades a visual gap for less jitter |
+| `frictionCombineRule` / `restitutionCombineRule`, `activeCollisionTypes` | raw Rapier passthroughs |
+
+Density matters more than it looks: impulse-driven controllers push bodies by
+force, so a crate with the default density reacts very differently from one at
+`density: 100`. Give props deliberate densities.
+
+## Sensors
+
+```ts
+const zone = cuboidCollider(world, zoneBody, [2, 1, 2], { sensor: true, mass: 0 });
+physics.setColliderEvents(zone, {
+  onIntersectionEnter: ({ other }) => { if (other.object3d === playerRoot) enterZone(); },
+  onIntersectionExit:  ({ other }) => { if (other.object3d === playerRoot) leaveZone(); },
+});
+```
+
+Always give sensors `mass: 0` when they hang off a dynamic body (e.g. a
+vehicle's boarding sensor) so they add no mass. Remember exit events fire both
+handler families — keep exit logic idempotent (see the physics-setup
+reference).
+
+## End-to-end: a genex model prop
+
+```ts
+import { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader.js";
+import { collidersFromObject } from "./controllers/shared/colliders.ts";
+
+const loader = new GLTFLoader();
+const gltf = await loader.loadAsync("./assets/models/weathered-wooden-barrel.glb");
+const barrel = gltf.scene;
+
+// 1. Normalize scale FIRST (target: 1.1 units tall).
+const bbox = new THREE.Box3().setFromObject(barrel);
+barrel.scale.setScalar(1.1 / (bbox.max.y - bbox.min.y));
+
+// 2. Wrap in an unscaled root, add to the scene, register, then colliders.
+const root = new THREE.Object3D();
+root.add(barrel);
+scene.add(root);
+const body = physics.createBody({ type: "dynamic", position: [3, 2, 0] }, root);
+collidersFromObject(world, body, root, "hull", { friction: 0.7, density: 500 });
+```
+
+Generating the GLB itself (`npx genex model "..."`) is covered by
+`$genex-ai-model`.