@genex-ai/cli-demo 1.19.0-dev.601 → 1.21.0-dev.603

package/dist/index.js

@@ -42,7 +42,7 @@ import {
   writeProject,
   writeUserToken,
   writeWorkspace
-} from "./chunk-YSMZVFJM.js";
+} from "./chunk-HEDRWUVP.js";
 import {
   CLI_CHANNEL,
   DEFAULT_API_URL,
@@ -2397,6 +2397,16 @@ async function recordTerminal(id, status, urls, cwd = process.cwd()) {
 async function countFailed(kind, cwd = process.cwd()) {
   return (await readLedger(cwd)).filter((e) => e.kind === kind && e.status === "failed").length;
 }
+async function trailingFailures(kind, cwd = process.cwd()) {
+  const rows = (await readLedger(cwd)).filter((e) => e.kind === kind);
+  let run2 = 0;
+  for (let i = rows.length - 1; i >= 0; i -= 1) {
+    const status = rows[i].status;
+    if (status === "completed") break;
+    if (status === "failed") run2 += 1;
+  }
+  return run2;
+}
 async function countOutcomes(kind, cwd = process.cwd()) {
   const rows = (await readLedger(cwd)).filter((e) => e.kind === kind);
   return {
@@ -2516,26 +2526,32 @@ function auditGenerationPlan(input) {
     const lane = m[1] ? LANE_OF_SKILL[m[1]] : void 0;
     if (lane) declaredLanes.add(lane);
   }
-  const lanesRun = new Set(ledger.map((e) => LANE_OF_KIND[e.kind] ?? e.kind));
+  const lanesRun = new Set(
+    ledger.filter((e) => e.status === "completed").map((e) => LANE_OF_KIND[e.kind] ?? e.kind)
+  );
+  const lanesPending = new Set(
+    ledger.filter((e) => e.status === "queued").map((e) => LANE_OF_KIND[e.kind] ?? e.kind).filter((lane) => !lanesRun.has(lane))
+  );
   const warnings = [];
   const owed = /* @__PURE__ */ new Map();
   for (const row of rows) {
     if (row.procedural || row.lane === null) continue;
     if (row.status !== "planned" && row.status !== "generating") continue;
     if (lanesRun.has(row.lane)) continue;
+    if (lanesPending.has(row.lane)) continue;
     if (row.lane === "skybox") continue;
     const held = owed.get(row.lane) ?? [];
     held.push(row.status === "generating" ? `${row.name} (says generating, not in this project's ledger)` : row.name);
     owed.set(row.lane, held);
   }
   for (const lane of declaredLanes) {
-    if (lanesRun.has(lane) || owed.has(lane) || lane === "skybox") continue;
+    if (lanesRun.has(lane) || lanesPending.has(lane) || owed.has(lane) || lane === "skybox") continue;
     if (!rows.some((r) => r.lane === lane)) owed.set(lane, ["declared as this subsystem's lane"]);
   }
   for (const [lane, names] of owed) {
     const shown = names.slice(0, 3).join(", ") + (names.length > 3 ? `, +${names.length - 3} more` : "");
     warnings.push(
-      `DESIGN.md plans generated ${lane} work (${shown}) and this project has never run a ${lane} generation \u2014 the plan says so and the generation ledger has nothing. Generate it (${LANE_COMMAND[lane] ?? `npx genex ${lane}`} "<prompt>" --no-wait), or change the row to say what happens instead and why.`
+      `DESIGN.md plans generated ${lane} work (${shown}) and this project has no ${lane} generation that landed \u2014 the plan says so and the generation ledger has nothing completed. Generate it (${LANE_COMMAND[lane] ?? `npx genex ${lane}`} "<prompt>" --no-wait), or change the row to say what happens instead and why.`
     );
   }
   const paidRows = rows.filter((r) => !r.procedural);
@@ -6056,7 +6072,18 @@ async function detectSurfaceScan(cwd = process.cwd()) {
   }
   return found;
 }
-var WIRED_BY_URL = /* @__PURE__ */ new Set(["model", "skybox", "sfx", "music", "texture", "video"]);
+var WIRED_BY_URL = /* @__PURE__ */ new Set([
+  "model",
+  "model_segment",
+  "model_rig",
+  "model_animation",
+  "skybox",
+  "sfx",
+  "music",
+  "voice",
+  "texture",
+  "video"
+]);
 var UNPICKED_AFTER_MS = 15 * 60 * 1e3;
 async function detectGenerationAudit(cwd = process.cwd()) {
   const ledger = await readLedger(cwd);
@@ -6067,7 +6094,10 @@ async function detectGenerationAudit(cwd = process.cwd()) {
   let haystack = "";
   const read = async (file) => {
     try {
-      haystack += await fs15.readFile(file, "utf8");
+      const raw = await fs15.readFile(file, "utf8");
+      const ext = path14.extname(file).toLowerCase();
+      if (ext === ".txt") return;
+      haystack += ext === ".ts" || ext === ".tsx" || ext === ".js" || ext === ".jsx" || ext === ".css" ? blankComments(raw) : ext === ".html" ? raw.replace(/<!--[\s\S]*?-->/g, (m) => m.replace(/[^\n]/g, " ")) : raw;
     } catch {
     }
   };
@@ -7164,9 +7194,20 @@ function applySkyboxGuard(prompt, raw) {
   if (guarded.length > SKYBOX_PROMPT_MAX) return { prompt, guarded: false, nouns };
   return { prompt: guarded, guarded: true, nouns };
 }
+var MODEL_TEXTURE_TIERS = ["standard", "detailed", "none"];
 function buildGenOptions(kind, opts) {
   const options = { ...opts.generationOptions };
   if (kind === "model" && opts.imageUrl) options.imageUrl = opts.imageUrl;
+  if (kind === "model") {
+    if (opts.texture === "none") options.texture = false;
+    else if (opts.texture !== void 0) options.textureQuality = opts.texture;
+    if (opts.geometry !== void 0) options.geometryQuality = opts.geometry;
+    if (opts.quad) options.quad = true;
+    if (opts.lowPoly) options.smartLowPoly = true;
+    if (opts.parts) options.generateParts = true;
+    if (opts.faceLimit !== void 0) options.faceLimit = opts.faceLimit;
+    if (opts.autoSize) options.autoSize = true;
+  }
   if (kind === "texture" && opts.terrain) options.terrain = true;
   if ((kind === "sfx" || kind === "music") && opts.duration) options.durationSeconds = opts.duration;
   if (kind === "voice") {
@@ -7217,6 +7258,11 @@ async function runGenerate(kind, opts) {
     const ref = opts.imageUrl.startsWith("data:") ? "local image" : opts.imageUrl;
     typedPrompt = `from image: ${path16.basename(ref).slice(0, 120)}`;
   }
+  if (kind === "model" && opts.texture !== void 0 && !MODEL_TEXTURE_TIERS.includes(opts.texture)) {
+    log.error(`--texture ${opts.texture} is a character texture size. \`genex model\` takes a texture TIER: ${MODEL_TEXTURE_TIERS.join("|")} (default detailed).`);
+    process.exitCode = 1;
+    return void 0;
+  }
   if (!typedPrompt) {
     log.error(`Missing prompt. Usage: ${c.cyan(`genex ${kind} "<prompt>"`)}`);
     process.exitCode = 1;
@@ -7550,7 +7596,10 @@ async function reportTerminal(kind, view, log, open = false, json = false, local
         const failures = await countFailed("video");
         (failures >= 2 ? log.plain : log.dim)(videoFailureAdvice(failures));
       } else if (!failure?.billing) {
-        const advice = laneFailureAdvice(kind, await countOutcomes(kind));
+        const advice = laneFailureAdvice(kind, {
+          ...await countOutcomes(kind),
+          trailingFailed: await trailingFailures(kind)
+        });
         if (advice) log.plain(advice);
       }
     }
@@ -7644,8 +7693,11 @@ function reportLocalFiles(result, log, json) {
   }
 }
 function laneFailureAdvice(kind, outcomes) {
-  if (outcomes.failed < 2 || outcomes.completed > 0) return null;
-  return `  ${c.bold(`\u270B ${outcomes.failed} ${kind} generations attempted in this project, ${outcomes.failed} failed, none succeeded.`)} That pattern is the LANE, not your prompt \u2014 a fourth attempt bills the same and returns the same. Build this one in code, use a different lane, or tell the user in one plain line what is unavailable and carry on with the rest of the game.`;
+  const run2 = outcomes.trailingFailed ?? (outcomes.completed > 0 ? 0 : outcomes.failed);
+  if (run2 < 2) return null;
+  const everSucceeded = outcomes.completed > 0;
+  const opening = everSucceeded ? `\u270B the last ${run2} ${kind} generations in this project all failed.` : `\u270B ${run2} ${kind} generations attempted in this project, ${run2} failed, none succeeded.`;
+  return `  ${c.bold(opening)} That pattern is the LANE, not your prompt \u2014 a fourth attempt bills the same and returns the same. Build this one in code, use a different lane, or tell the user in one plain line what is unavailable and carry on with the rest of the game.`;
 }
 function videoFailureAdvice(failures) {
   if (failures >= 2) {
@@ -7780,7 +7832,14 @@ var HINT_URL_KINDS = /* @__PURE__ */ new Set([
 ]);
 function assetHint(kind, view, url) {
   const hint = {
-    model: `Standard GLB \u2014 load with GLTFLoader straight from the URL \u2014 see the genex-ai-model skill.`,
+    // "straight from the URL" was the OPPOSITE of the kit's own rule, which
+    // reads: "EVERY tier loads a game-ready rung — provider-raw originals are
+    // archival/remix source, not game assets" (controllers/quality/pick-asset.ts).
+    // A bare GLTFLoader on this URL fetches the original — a Tripo prop is
+    // ~500k tris and 3x4096 textures, and a scene of them floored an M4 Max.
+    // The url clause stays: the BARE url is the right thing to store, because
+    // `pickModel` resolves the tier's rung at load time.
+    model: `Standard GLB. Load it through the quality kit \u2014 createGltfLoader(renderer) then loadModelWithFallback(url, tier, (u) => gltf.loader.loadAsync(u), { ktx2: gltf.ktx2 }) \u2014 so the tier gets a game-ready rung; a bare GLTFLoader on this URL fetches the provider-raw original (~500k tris, 3x4096 textures). Install it with npx genex controller quality. See genex-ai-model.`,
     // Unreachable while the lane is paused (see src/index.ts) — kept so a
     // restore is one deletion. Games that already ship a panorama still load
     // it this way.
@@ -7801,9 +7860,9 @@ function assetHint(kind, view, url) {
     character: `Install the controller and current manifest with genex controller character --character ${view.id}.`,
     character_animation: "The action is now part of the character's current manifest; refresh the local controller manifest before testing.",
     character_motion: `The clips are part of the character's current manifest \u2014 install them with genex controller character --character ${view.id}, then play the game and watch the motion on the real character before calling it done.`,
-    model_segment: `One GLB with NAMED parts \u2014 load with GLTFLoader, then getObjectByName / traverse scene.children to move, detach, or swap a part. Part names print above when the provider reports them.`,
-    model_rig: `Rigged GLB (Tripo skeleton) \u2014 load with GLTFLoader; give it motion with genex model animate ${view.id} --preset walk, or drive the bones in code.`,
-    model_animation: `Animated GLB \u2014 load with GLTFLoader and play its clips via THREE.AnimationMixer (gltf.animations).`
+    model_segment: `One GLB with NAMED parts \u2014 load it through the quality kit (loadModelWithFallback, as for a plain model), then getObjectByName / traverse scene.children to move, detach, or swap a part. Part names print above when the provider reports them.`,
+    model_rig: `Rigged GLB (Tripo skeleton) \u2014 load it through the quality kit (loadModelWithFallback); give it motion with genex model animate ${view.id} --preset walk, or drive the bones in code.`,
+    model_animation: `Animated GLB \u2014 load it through the quality kit (loadModelWithFallback) and play its clips via THREE.AnimationMixer (gltf.animations).`
   };
   const base = hint[kind];
   return url && HINT_URL_KINDS.has(kind) ? `${base} url = "${url}"` : base;
@@ -7982,7 +8041,111 @@ function writeJson(value) {
 }
 
 // src/commands/model-sub.ts
-var MODEL_SUBCOMMANDS = ["segment", "rig", "animate"];
+import fs18 from "fs/promises";
+import path17 from "path";
+var MODEL_SUBCOMMANDS = ["segment", "rig", "animate", "import"];
+function apiErrorMessage(data, fallback) {
+  if (typeof data !== "object" || data === null) return fallback;
+  const body = data;
+  if (typeof body.message === "string" && body.message) return body.message;
+  if (typeof body.error === "string" && body.error) return body.error;
+  return fallback;
+}
+var MODEL_IMPORT_MAX_BYTES = 64 * 1024 * 1024;
+var GLB_MAGIC = 1179937895;
+async function importModelFile(args) {
+  const { log } = args;
+  const filePath = args.filePath.trim();
+  if (!/\.glb$/i.test(filePath)) {
+    log.error(`\`import\` takes a .glb file (binary glTF 2.0). Export ${path17.basename(filePath) || "the model"} as GLB first \u2014 Blender: File \u2192 Export \u2192 glTF 2.0, format "glTF Binary".`);
+    return null;
+  }
+  let bytes;
+  try {
+    bytes = await fs18.readFile(filePath);
+  } catch {
+    log.error(`Couldn't read ${filePath}.`);
+    return null;
+  }
+  if (bytes.byteLength > MODEL_IMPORT_MAX_BYTES) {
+    log.error(`${path17.basename(filePath)} is ${(bytes.byteLength / 1e6).toFixed(1)} MB; imports are capped at ${MODEL_IMPORT_MAX_BYTES / 1024 / 1024} MB. Shrink its textures (they are usually the bulk) and try again.`);
+    return null;
+  }
+  if (bytes.byteLength < 12 || bytes.readUInt32LE(0) !== GLB_MAGIC) {
+    log.error(`${path17.basename(filePath)} is not a GLB (no glTF magic). A .gltf + .bin pair must be exported as one binary .glb.`);
+    return null;
+  }
+  const headers = { "Content-Type": "application/json", Authorization: `Bearer ${args.token}` };
+  const minted = await apiFetch(`${args.apiUrl}/api/generations/import`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ filename: path17.basename(filePath), bytes: bytes.byteLength, contentType: "model/gltf-binary" })
+  });
+  if (printedStructuredError(minted)) return null;
+  if (!minted.ok) {
+    const data = await minted.json().catch(() => ({}));
+    log.error(apiErrorMessage(data, `Couldn't start the import (HTTP ${minted.status}).`));
+    return null;
+  }
+  const { id, uploadUrl, url } = await minted.json();
+  log.dim(`  uploading ${path17.basename(filePath)} (${(bytes.byteLength / 1e6).toFixed(1)} MB)\u2026`);
+  const put = await fetch(uploadUrl, {
+    method: "PUT",
+    headers: { "Content-Type": "model/gltf-binary", "Content-Length": String(bytes.byteLength) },
+    body: new Uint8Array(bytes)
+  });
+  if (!put.ok) {
+    log.error(`Upload failed (HTTP ${put.status}). Nothing was charged \u2014 run the import again.`);
+    return null;
+  }
+  const done = await apiFetch(`${args.apiUrl}/api/generations/import/${encodeURIComponent(id)}/complete`, {
+    method: "POST",
+    headers
+  });
+  if (printedStructuredError(done)) return null;
+  if (!done.ok) {
+    const data = await done.json().catch(() => ({}));
+    log.error(apiErrorMessage(data, `The import was refused (HTTP ${done.status}).`));
+    return null;
+  }
+  const view = await done.json();
+  return { id, url, inspection: view.inspection ?? null };
+}
+async function runModelImport(opts) {
+  const log = createLogger({ quiet: opts.quiet || opts.json });
+  const filePath = opts.sourceId?.trim();
+  if (!filePath) {
+    log.error(`Missing file. Usage: ${c.cyan("genex model import <file.glb>")}`);
+    process.exitCode = 1;
+    return;
+  }
+  const token = opts.token ?? await readUserToken(opts.envPath);
+  if (!token) {
+    log.error("Not authorized. Run `genex init` first to sign in.");
+    process.exitCode = 1;
+    return;
+  }
+  const project = await readProject();
+  const apiUrl = getApiUrl(opts.apiUrl ?? project?.apiUrl);
+  const imported = await importModelFile({ apiUrl, token, filePath, log });
+  if (!imported) {
+    process.exitCode = 1;
+    return;
+  }
+  const next = {
+    rig: `genex model rig ${imported.id}`,
+    character: `genex character import ${filePath}`
+  };
+  if (opts.json) {
+    writeJson({ kind: "model", id: imported.id, status: "completed", url: imported.url, inspection: imported.inspection, nextCommands: next });
+    return;
+  }
+  const facts = imported.inspection ? ` \xB7 ${imported.inspection.faceCount.toLocaleString("en-US")} faces${imported.inspection.skinned ? " \xB7 already skinned" : ""}` : "";
+  log.success(`Imported (${imported.id})${facts}`);
+  log.plain(`  ${imported.url}`);
+  log.plain(`  Rig it (7 body plans): ${c.cyan(next.rig)}`);
+  log.plain(`  Or make it a playable humanoid: ${c.cyan(next.character)}`);
+}
 var SEGMENT_GRANULARITIES = ["simple", "balanced", "detailed"];
 var MODEL_RIG_TYPES = [
   "biped",
@@ -8271,8 +8434,8 @@ async function toRow(e, v, cwd) {
 }
 
 // src/commands/controller.ts
-import fs19 from "fs/promises";
-import path18 from "path";
+import fs20 from "fs/promises";
+import path19 from "path";
 
 // ../../packages/meshy-animation-catalog/src/index.ts
 import { createHash } from "crypto";
@@ -17402,9 +17565,9 @@ function searchMeshyAnimations(query, options = {}) {
 }
 
 // src/lib/anims.ts
-import fs18 from "fs/promises";
-import path17 from "path";
-var ANIMS_DEST = path17.join("public", "assets", "anims");
+import fs19 from "fs/promises";
+import path18 from "path";
+var ANIMS_DEST = path18.join("public", "assets", "anims");
 var HIDDEN_TAG = "reference";
 async function runAnims(opts) {
   const log = createLogger({ quiet: opts.quiet });
@@ -17420,7 +17583,7 @@ async function runAnims(opts) {
     printCatalog(log, manifest, selectors);
     return;
   }
-  const controllerMarker = path17.join(root, "src", "controllers", "character");
+  const controllerMarker = path18.join(root, "src", "controllers", "character");
   if (!await exists2(controllerMarker)) {
     log.error(
       `No character controller in this game (missing ${c.cyan("src/controllers/character/")}).`
@@ -17429,11 +17592,11 @@ async function runAnims(opts) {
     process.exitCode = 1;
     return;
   }
-  const destDir = path17.join(root, ANIMS_DEST);
-  const gameManifestPath = path17.join(destDir, "manifest.json");
+  const destDir = path18.join(root, ANIMS_DEST);
+  const gameManifestPath = path18.join(destDir, "manifest.json");
   if (opts.reset) {
-    await fs18.rm(destDir, { recursive: true, force: true });
-    log.step(`Cleared ${c.cyan(ANIMS_DEST + path17.sep)} (--reset)`);
+    await fs19.rm(destDir, { recursive: true, force: true });
+    log.step(`Cleared ${c.cyan(ANIMS_DEST + path18.sep)} (--reset)`);
   }
   if (selectors.length === 0) {
     const installed = await readGameManifest(gameManifestPath);
@@ -17471,35 +17634,35 @@ async function runAnims(opts) {
     }
   }
   const wanted = [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
-  const cacheDir = path17.join(
+  const cacheDir = path18.join(
     opts.cacheDir ?? getAnimsCacheDir(),
     `${manifest.library}-v${manifest.version}`
   );
-  await fs18.mkdir(cacheDir, { recursive: true });
-  await fs18.mkdir(destDir, { recursive: true });
+  await fs19.mkdir(cacheDir, { recursive: true });
+  await fs19.mkdir(destDir, { recursive: true });
   const base = getAnimsBase(opts.animsBase);
   let installedCount = 0;
   let presentCount = 0;
   let addedBytes = 0;
   const failures = [];
   for (const entry of wanted) {
-    const dest = path17.join(destDir, entry.file);
+    const dest = path18.join(destDir, entry.file);
     if (await hasSize(dest, entry.bytes)) {
       presentCount++;
       continue;
     }
     try {
-      const cached = path17.join(cacheDir, entry.file);
+      const cached = path18.join(cacheDir, entry.file);
       if (!await hasSize(cached, entry.bytes)) {
         const res = await fetch(base + entry.file);
         if (!res.ok) throw new Error(`HTTP ${res.status}`);
         const buf = Buffer.from(await res.arrayBuffer());
-        await fs18.writeFile(cached, buf);
+        await fs19.writeFile(cached, buf);
       }
-      await fs18.copyFile(cached, dest);
+      await fs19.copyFile(cached, dest);
       installedCount++;
       addedBytes += entry.bytes;
-      log.dim(`  ${path17.join(ANIMS_DEST, entry.file)} (${formatMb(entry.bytes)})`);
+      log.dim(`  ${path18.join(ANIMS_DEST, entry.file)} (${formatMb(entry.bytes)})`);
     } catch (err) {
       failures.push(`${entry.name} (${err instanceof Error ? err.message : String(err)})`);
     }
@@ -17515,13 +17678,13 @@ async function runAnims(opts) {
     version: manifest.version,
     clips: [...union].sort((a, b) => a.localeCompare(b))
   };
-  await fs18.writeFile(gameManifestPath, JSON.stringify(gameManifest, null, 2) + "\n");
+  await fs19.writeFile(gameManifestPath, JSON.stringify(gameManifest, null, 2) + "\n");
   log.plain("");
   const parts = [`${installedCount} clip${installedCount === 1 ? "" : "s"} installed`];
   if (presentCount > 0) parts.push(`${presentCount} already present`);
   if (bundledSkips > 0) parts.push(`${bundledSkips} already bundled in animation-library.glb`);
   log.success(
-    `${parts.join(", ")} \u2192 ${c.cyan(ANIMS_DEST + path17.sep)}${addedBytes > 0 ? ` (+${formatMb(addedBytes)})` : ""}`
+    `${parts.join(", ")} \u2192 ${c.cyan(ANIMS_DEST + path18.sep)}${addedBytes > 0 ? ` (+${formatMb(addedBytes)})` : ""}`
   );
   for (const [selector, entries] of resolved) {
     const names = entries.filter((e) => !coreNames.has(e.name)).map((e) => e.name);
@@ -17553,8 +17716,8 @@ async function loadManifest(baseOverride) {
     }
   } catch {
   }
-  const snapshotPath = path17.join(getTemplatesDir(), "controllers", "assets", "anims-manifest.json");
-  const manifest = JSON.parse(await fs18.readFile(snapshotPath, "utf8"));
+  const snapshotPath = path18.join(getTemplatesDir(), "controllers", "assets", "anims-manifest.json");
+  const manifest = JSON.parse(await fs19.readFile(snapshotPath, "utf8"));
   return { manifest, source: "snapshot" };
 }
 function resolveSelectors(manifest, selectors) {
@@ -17672,21 +17835,21 @@ function printCatalog(log, manifest, selectors) {
 }
 async function readGameManifest(file) {
   try {
-    return JSON.parse(await fs18.readFile(file, "utf8"));
+    return JSON.parse(await fs19.readFile(file, "utf8"));
   } catch {
     return null;
   }
 }
 async function hasSize(file, bytes) {
   try {
-    return (await fs18.stat(file)).size === bytes;
+    return (await fs19.stat(file)).size === bytes;
   } catch {
     return false;
   }
 }
 async function exists2(p) {
   try {
-    await fs18.access(p);
+    await fs19.access(p);
     return true;
   } catch {
     return false;
@@ -17819,6 +17982,7 @@ var CONTROLLER_FILE_SETS = {
     code: [
       "quality/tier.ts",
       "quality/governor.ts",
+      "quality/deadline.ts",
       "quality/pick-asset.ts",
       "quality/gltf-loader.ts",
       "quality/depth.ts",
@@ -17886,8 +18050,8 @@ var CONTROLLER_FILE_SETS = {
     ]
   }
 };
-var CODE_DEST = path18.join("src", "controllers");
-var ASSETS_DEST = path18.join("public", "assets");
+var CODE_DEST = path19.join("src", "controllers");
+var ASSETS_DEST = path19.join("public", "assets");
 async function runController(opts) {
   const log = createLogger({ quiet: opts.quiet });
   if (opts.kind?.trim() === "anims") {
@@ -17904,31 +18068,31 @@ async function runController(opts) {
     process.exitCode = 1;
     return;
   }
-  const srcDir = path18.join(getTemplatesDir(), "controllers");
+  const srcDir = path19.join(getTemplatesDir(), "controllers");
   const root = opts.cwd ?? process.cwd();
   const set = CONTROLLER_FILE_SETS[kind];
   log.plain(c.bold(`genex controller ${kind}`));
   log.plain("");
-  log.step(`Installing the ${kind} controller into ${c.cyan(CODE_DEST + path18.sep)}`);
+  log.step(`Installing the ${kind} controller into ${c.cyan(CODE_DEST + path19.sep)}`);
   const plan = [
-    ...set.code.map((rel) => ({ from: rel, rel: path18.join(CODE_DEST, rel) })),
+    ...set.code.map((rel) => ({ from: rel, rel: path19.join(CODE_DEST, rel) })),
     ...set.assets.map((rel) => ({
       from: rel,
-      rel: path18.join(ASSETS_DEST, path18.basename(rel))
+      rel: path19.join(ASSETS_DEST, path19.basename(rel))
     }))
   ];
   let copied = 0;
   let skipped = 0;
   try {
     for (const file of plan) {
-      const dest = path18.join(root, file.rel);
+      const dest = path19.join(root, file.rel);
       if (!opts.force && await exists3(dest)) {
         skipped++;
         log.dim(`  skipped ${file.rel} (exists \u2014 use --force to overwrite)`);
         continue;
       }
-      await fs19.mkdir(path18.dirname(dest), { recursive: true });
-      await fs19.copyFile(path18.join(srcDir, file.from), dest);
+      await fs20.mkdir(path19.dirname(dest), { recursive: true });
+      await fs20.copyFile(path19.join(srcDir, file.from), dest);
       copied++;
       log.dim(`  ${file.rel}`);
     }
@@ -17981,7 +18145,7 @@ async function runController(opts) {
   for (const line of set.sketch) {
     log.dim(`       ${line}`);
   }
-  if (kind === "character" && !await exists3(path18.join(root, ASSETS_DEST, "meshy-character.json"))) {
+  if (kind === "character" && !await exists3(path19.join(root, ASSETS_DEST, "meshy-character.json"))) {
     log.plain("");
     log.plain(
       `  ${stepOffset + 3}. This game has no generated character yet \u2014 ${c.cyan(
@@ -18009,13 +18173,13 @@ async function installMeshyCharacterManifest(args) {
   }
   const body = await response.json();
   const manifest = body.manifest;
-  if (!manifest || manifest.schema !== 1 || manifest.rig !== "meshy-biped" || manifest.characterId !== args.characterId || typeof manifest.model?.url !== "string" || typeof manifest.model.skeletonSignature !== "string" || !Array.isArray(manifest.clips) || !manifest.locomotion?.slots) {
+  if (!manifest || manifest.schema !== 1 || manifest.rig !== "meshy-biped" && manifest.rig !== "uthana-biped" || manifest.characterId !== args.characterId || typeof manifest.model?.url !== "string" || typeof manifest.model.skeletonSignature !== "string" || !Array.isArray(manifest.clips) || !manifest.locomotion?.slots) {
     throw new Error("The API returned an invalid Meshy character manifest.");
   }
   assertCompleteMeshyControllerPack(manifest);
-  const destination = path18.join(args.root, ASSETS_DEST, "meshy-character.json");
-  await fs19.mkdir(path18.dirname(destination), { recursive: true });
-  await fs19.writeFile(
+  const destination = path19.join(args.root, ASSETS_DEST, "meshy-character.json");
+  await fs20.mkdir(path19.dirname(destination), { recursive: true });
+  await fs20.writeFile(
     destination,
     `${JSON.stringify(manifest, null, 2)}
 `
@@ -18025,6 +18189,13 @@ async function installMeshyCharacterManifest(args) {
   const pack2 = manifest.controllerPack;
   if (typeof pack2?.key === "string" && typeof pack2.version === "number") {
     args.log.success(`Meshy controller pack ${pack2.key} v${pack2.version}`);
+  } else if (manifest.rig === "uthana-biped") {
+    const slotCount = Object.keys(manifest.locomotion?.slots ?? {}).length;
+    if (slotCount === 0) {
+      args.log.warn(`Uthana-rigged import with no locomotion yet \u2014 run \`genex character animate ${args.characterId} --locomotion\` or the body will stand still.`);
+    } else {
+      args.log.success(`Uthana-rigged import \xB7 ${slotCount} locomotion slot${slotCount === 1 ? "" : "s"} from generated motion`);
+    }
   } else {
     args.log.warn("Legacy Meshy manifest \u2014 regenerate the character for the immutable preview-reviewed neutral-v3 locomotion pack.");
   }
@@ -18153,14 +18324,14 @@ function assertCompleteMeshyControllerPack(manifest) {
 }
 async function installFallbackAvatar(args) {
   const { root, srcDir, log } = args;
-  const dest = path18.join(root, ASSETS_DEST, "avatar.vrm");
-  await fs19.mkdir(path18.dirname(dest), { recursive: true });
-  await fs19.copyFile(path18.join(srcDir, "assets", "default-avatar.vrm"), dest);
+  const dest = path19.join(root, ASSETS_DEST, "avatar.vrm");
+  await fs20.mkdir(path19.dirname(dest), { recursive: true });
+  await fs20.copyFile(path19.join(srcDir, "assets", "default-avatar.vrm"), dest);
   log.dim("  public/assets/avatar.vrm (fallback avatar \u2014 bundled CC0 default)");
 }
 async function exists3(p) {
   try {
-    await fs19.access(p);
+    await fs20.access(p);
     return true;
   } catch {
     return false;
@@ -18168,8 +18339,8 @@ async function exists3(p) {
 }
 
 // src/commands/character.ts
-import fs20 from "fs/promises";
-import path19 from "path";
+import fs21 from "fs/promises";
+import path20 from "path";
 function exactAnimation(selector) {
   const trimmed = selector.trim();
   if (/^-?\d+$/.test(trimmed)) return animationById(Number(trimmed));
@@ -18201,7 +18372,7 @@ async function context(opts) {
   return { token, apiUrl: getApiUrl(opts.apiUrl ?? project?.apiUrl) };
 }
 var CHARACTER_BRIEF_MAX_CHARS = 600;
-function apiErrorMessage(data, fallback) {
+function apiErrorMessage2(data, fallback) {
   if (typeof data !== "object" || data === null) return fallback;
   const body = data;
   if (typeof body.message === "string" && body.message) return body.message;
@@ -18225,7 +18396,7 @@ async function quote(url, token, body) {
   if (printedStructuredError(response)) return null;
   if (!response.ok) {
     const data = await response.json().catch(() => ({}));
-    throw new Error(apiErrorMessage(data, `Quote failed (HTTP ${response.status}).`));
+    throw new Error(apiErrorMessage2(data, `Quote failed (HTTP ${response.status}).`));
   }
   return (await response.json()).quote;
 }
@@ -18249,7 +18420,7 @@ function showAmbiguity(selector, candidates, log, json = false) {
   }
   process.exitCode = 1;
 }
-var INSTALLED_MANIFEST = path19.join("public", "assets", "meshy-character.json");
+var INSTALLED_MANIFEST = path20.join("public", "assets", "meshy-character.json");
 async function resolveAdoptTarget(selector) {
   const trimmed = selector?.trim();
   if (trimmed && !trimmed.endsWith(".json")) {
@@ -18258,7 +18429,7 @@ async function resolveAdoptTarget(selector) {
   const file = trimmed ?? INSTALLED_MANIFEST;
   let raw;
   try {
-    raw = await fs20.readFile(file, "utf8");
+    raw = await fs21.readFile(file, "utf8");
   } catch {
     return {
       ok: false,
@@ -18334,6 +18505,81 @@ async function runCharacterAdopt(opts) {
     }
   });
 }
+async function runCharacterImport(opts) {
+  const log = createLogger({ quiet: opts.quiet || opts.json });
+  const filePath = opts.importPath?.trim();
+  if (!filePath) {
+    fail2(opts, "Missing file. Usage: genex character import <file.glb> [--height 1.8] [--no-fingers]");
+    return;
+  }
+  if (opts.texture !== void 0 || opts.ultra === false || opts.pose !== void 0 || opts.polycount !== void 0) {
+    fail2(opts, "--texture / --no-ultra / --pose / --polycount are Meshy generation knobs; an import keeps your mesh exactly as it is. Uthana only adds the skeleton (--no-fingers skips finger joints).");
+    return;
+  }
+  if (opts.controllerPack === false || (opts.actions?.length ?? 0) > 0) {
+    fail2(opts, "An imported character has no Meshy controller pack and takes no catalog --animation: its motion comes from `genex character animate <id> --locomotion` and plain-word verbs.");
+    return;
+  }
+  const ctx = await context(opts);
+  if (!ctx) {
+    fail2(opts, "Not authorized. Run `genex init` first to sign in.");
+    return;
+  }
+  const imported = await importModelFile({ apiUrl: ctx.apiUrl, token: ctx.token, filePath, log });
+  if (!imported) {
+    process.exitCode = 1;
+    return;
+  }
+  const body = {
+    sourceGenerationId: imported.id,
+    includeFingers: opts.fingers !== false,
+    ...opts.height === void 0 ? {} : { heightMeters: opts.height }
+  };
+  const price = await quote(`${ctx.apiUrl}/api/characters/import/quote`, ctx.token, body);
+  if (!price) {
+    process.exitCode = 1;
+    return;
+  }
+  if (!opts.json) {
+    log.plain(c.bold("Character import quote"));
+    log.plain(`  ${price.credits} Genex credits \xB7 Uthana auto-rig${opts.fingers === false ? " (no finger joints)" : " with finger joints"} \xB7 the model upload was free`);
+    log.plain("");
+  }
+  await runWorkflow({
+    opts,
+    ctx,
+    kind: "character",
+    prompt: `Import ${path20.basename(filePath)} as a rigged character`,
+    createPath: "/api/characters/import",
+    body,
+    quote: price,
+    completed: (view) => {
+      const confidence = typeof view.metadata?.autoRigConfidence === "number" ? view.metadata.autoRigConfidence : null;
+      const next = {
+        locomotion: `genex character animate ${view.id} --locomotion`,
+        install: `genex controller character --character ${view.id}`
+      };
+      if (opts.json) {
+        writeJson({
+          kind: "character",
+          status: view.status,
+          characterId: view.id,
+          modelGenerationId: imported.id,
+          rigProvider: "uthana",
+          autoRigConfidence: confidence,
+          nextCommand: next.locomotion,
+          nextCommands: next
+        });
+        return;
+      }
+      log.success(`Rigged by Uthana${confidence === null ? "" : ` (confidence ${confidence.toFixed(2)})`}: ${c.cyan(view.id)}`);
+      log.plain("  It has a skeleton and no clips yet. Give it the walk/run set, then point the game at it:");
+      log.plain(`    ${c.cyan(next.locomotion)}`);
+      log.plain(`    ${c.cyan(next.install)}`);
+      log.dim('  Any move in plain words: genex character animate <id> "<what it should do>" \xB7 the Meshy catalog does not apply to this rig.');
+    }
+  });
+}
 async function runCharacter(opts) {
   if (opts.directText) {
     await runDirectTextCharacter(opts);
@@ -18362,7 +18608,7 @@ async function postWorkflow(url, token, body) {
   if (printedStructuredError(response)) return null;
   if (!response.ok) {
     const data2 = await response.json().catch(() => ({}));
-    throw new Error(apiErrorMessage(data2, `Character workflow request failed (HTTP ${response.status}).`));
+    throw new Error(apiErrorMessage2(data2, `Character workflow request failed (HTTP ${response.status}).`));
   }
   const data = await response.json();
   if (typeof data.id !== "string" || data.id.length === 0) {
@@ -18432,7 +18678,11 @@ async function runCharacterConcept(opts) {
     return;
   }
   if (opts.polycount !== void 0) {
-    fail2(opts, "--polycount is only available with --direct-text. The approval flow remeshes only after finalize approval.", "character_concept");
+    fail2(opts, "--polycount is only available with --direct-text. The approval flow takes its face budget on `character finalize --approve-remesh <faces>`.", "character_concept");
+    return;
+  }
+  if (opts.texture !== void 0 || opts.ultra === false || opts.pose !== void 0) {
+    fail2(opts, "--texture / --no-ultra / --pose apply to the paid mesh call: pass them to `character preview` (guided) or `character --direct-text` / `creature` (one shot). Concepts are images.", "character_concept");
     return;
   }
   if (opts.controllerPack === false) {
@@ -18528,10 +18778,26 @@ async function runDirectTextCharacter(opts) {
       actionIds: resolved.actionIds,
       controllerPack,
       ...opts.height === void 0 ? {} : { heightMeters: opts.height },
-      targetPolycount: opts.polycount ?? 1e4
+      targetPolycount: opts.polycount ?? 1e4,
+      ...meshyQualityOptions(opts),
+      ...opts.pose === void 0 ? {} : { poseMode: opts.pose }
     }
   });
 }
+var CHARACTER_TEXTURE_SIZES = ["2k", "4k", "8k"];
+var REMESH_TARGET_MIN = 1e4;
+var REMESH_TARGET_MAX = 1e5;
+function meshyQualityOptions(opts) {
+  return {
+    ...opts.texture === void 0 ? {} : { textureResolution: opts.texture },
+    ...opts.ultra === false ? { ultraMode: false } : {}
+  };
+}
+function badCharacterTexture(opts) {
+  if (opts.texture === void 0) return null;
+  if (CHARACTER_TEXTURE_SIZES.includes(opts.texture)) return null;
+  return `--texture ${opts.texture} is a \`genex model\` tier. A character takes a texture SIZE: ${CHARACTER_TEXTURE_SIZES.join("|")} (default 4k).`;
+}
 async function runCharacterPreview(opts) {
   const log = createLogger({ quiet: opts.quiet || opts.json });
   const conceptId = opts.conceptId?.trim();
@@ -18552,7 +18818,12 @@ async function runCharacterPreview(opts) {
     fail2(opts, "Not authorized. Run `genex init` first to sign in.", "character_preview");
     return;
   }
-  const body = { candidateIndex: opts.candidate, userApproved: true };
+  const badTexture = badCharacterTexture(opts);
+  if (badTexture) {
+    fail2(opts, badTexture, "character_preview");
+    return;
+  }
+  const body = { candidateIndex: opts.candidate, userApproved: true, ...meshyQualityOptions(opts) };
   const basePath = `/api/characters/concepts/${encodeURIComponent(conceptId)}/previews`;
   const price = await quote(`${ctx.apiUrl}${basePath}/quote`, ctx.token, body);
   if (!price) {
@@ -18590,12 +18861,20 @@ async function runCharacterFinalize(opts) {
     fail2(opts, "STOP: finalization requires explicit user approval of all four preview views. Re-run with --user-approved only after approval.");
     return;
   }
-  if (opts.approveRemesh !== 1e4) {
-    fail2(opts, "--approve-remesh must be exactly 10000. No other rigging-copy target is accepted.");
+  const remeshTarget = opts.approveRemesh;
+  if (remeshTarget === void 0 || !Number.isInteger(remeshTarget) || remeshTarget < REMESH_TARGET_MIN || remeshTarget > REMESH_TARGET_MAX) {
+    fail2(
+      opts,
+      `--approve-remesh <faces> is required: the face budget of the rigging copy, ${REMESH_TARGET_MIN}-${REMESH_TARGET_MAX} (10000 for a crowd body, 30000 or more for a hero). The number is the approval.`
+    );
     return;
   }
   if (opts.polycount !== void 0) {
-    fail2(opts, "Do not combine --polycount with finalize; --approve-remesh 10000 is the only accepted rigging-copy target.");
+    fail2(opts, "Do not combine --polycount with finalize; --approve-remesh <faces> is the rigging-copy target.");
+    return;
+  }
+  if (opts.texture !== void 0 || opts.ultra === false) {
+    fail2(opts, "--texture / --no-ultra belong to `genex character preview` \u2014 the preview is the paid Meshy call; finalize remeshes and rigs what it made.");
     return;
   }
   if (opts.controllerPack === false) {
@@ -18615,7 +18894,7 @@ async function runCharacterFinalize(opts) {
   const body = {
     ...requestedBuild(opts, resolved.actionIds),
     userApproved: true,
-    approvedRemeshTarget: 1e4
+    approvedRemeshTarget: remeshTarget
   };
   const basePath = `/api/characters/previews/${encodeURIComponent(previewId)}/finalize`;
   const price = await quote(`${ctx.apiUrl}${basePath}/quote`, ctx.token, body);
@@ -18626,7 +18905,7 @@ async function runCharacterFinalize(opts) {
   if (!opts.json) {
     log.plain(c.bold("Character finalize quote"));
     log.plain(`  ${price.credits} Genex credits = base ${price.baseCredits} + actions ${price.animationCredits}`);
-    log.plain("  Approved rigging copy: 10,000 faces; the high-detail source remains preserved in R2.");
+    log.plain(`  Approved rigging copy: ${remeshTarget.toLocaleString("en-US")} faces; the high-detail source remains preserved in R2.`);
     log.plain("");
   }
   await runWorkflow({
@@ -18741,22 +19020,22 @@ async function context2(opts) {
   const project = await readProject();
   return { token, apiUrl: getApiUrl(opts.apiUrl ?? project?.apiUrl) };
 }
-async function readVideo(path26, log) {
+async function readVideo(path27, log) {
   let bytes;
   try {
-    bytes = await readFile(path26);
+    bytes = await readFile(path27);
   } catch {
-    log.error(`Can't read ${path26}.`);
+    log.error(`Can't read ${path27}.`);
     return null;
   }
   if (bytes.byteLength > MAX_VIDEO_BYTES) {
-    log.error(`${basename(path26)} is ${(bytes.byteLength / 1e6).toFixed(0)} MB \u2014 the limit is ${MAX_VIDEO_BYTES / 1e6} MB.`);
+    log.error(`${basename(path27)} is ${(bytes.byteLength / 1e6).toFixed(0)} MB \u2014 the limit is ${MAX_VIDEO_BYTES / 1e6} MB.`);
     return null;
   }
   return bytes;
 }
-async function uploadVideo(apiUrl, token, characterId, path26, bytes, log) {
-  const contentType = /\.mov$/i.test(path26) ? "video/quicktime" : "video/mp4";
+async function uploadVideo(apiUrl, token, characterId, path27, bytes, log) {
+  const contentType = /\.mov$/i.test(path27) ? "video/quicktime" : "video/mp4";
   const minted = await apiFetch(
     `${apiUrl}/api/characters/${encodeURIComponent(characterId)}/motions/video-url`,
     {
@@ -18771,7 +19050,7 @@ async function uploadVideo(apiUrl, token, characterId, path26, bytes, log) {
     return null;
   }
   const { uploadUrl, videoUrl } = await minted.json();
-  log.dim(`  uploading ${basename(path26)} (${(bytes.byteLength / 1e6).toFixed(1)} MB)\u2026`);
+  log.dim(`  uploading ${basename(path27)} (${(bytes.byteLength / 1e6).toFixed(1)} MB)\u2026`);
   const put = await fetch(uploadUrl, {
     method: "PUT",
     headers: { "Content-Type": contentType, "Content-Length": String(bytes.byteLength) },
@@ -19087,8 +19366,8 @@ function rank(items, query) {
 }
 
 // src/commands/motion.ts
-import fs21 from "fs/promises";
-import path20 from "path";
+import fs22 from "fs/promises";
+import path21 from "path";
 
 // src/lib/motion/npz.ts
 import zlib from "zlib";
@@ -20339,7 +20618,7 @@ async function motionGen(opts, log) {
   }
   if (opts.constraintsPath !== void 0) {
     try {
-      const raw = await fs21.readFile(opts.constraintsPath, "utf8");
+      const raw = await fs22.readFile(opts.constraintsPath, "utf8");
       generationOptions.constraints = JSON.parse(raw);
     } catch {
       log.error(`Couldn't read the --constraints JSON at ${opts.constraintsPath}.`);
@@ -20363,10 +20642,10 @@ async function motionGen(opts, log) {
 async function expandTakes(selectors) {
   const out = [];
   for (const sel of selectors) {
-    const st = await fs21.stat(sel).catch(() => null);
+    const st = await fs22.stat(sel).catch(() => null);
     if (st?.isDirectory()) {
-      const names = await fs21.readdir(sel);
-      for (const n of names.sort()) if (n.endsWith(".npz")) out.push(path20.join(sel, n));
+      const names = await fs22.readdir(sel);
+      for (const n of names.sort()) if (n.endsWith(".npz")) out.push(path21.join(sel, n));
     } else if (st?.isFile()) {
       out.push(sel);
     } else {
@@ -20401,7 +20680,7 @@ async function motionVerify(opts, log) {
   let gates = DEFAULT_GATES;
   if (opts.gatesPath) {
     try {
-      gates = mergeGates(DEFAULT_GATES, JSON.parse(await fs21.readFile(opts.gatesPath, "utf8")));
+      gates = mergeGates(DEFAULT_GATES, JSON.parse(await fs22.readFile(opts.gatesPath, "utf8")));
     } catch {
       log.error(`Couldn't read the --gates JSON at ${opts.gatesPath}.`);
       process.exitCode = 1;
@@ -20423,9 +20702,9 @@ async function motionVerify(opts, log) {
   }
   const reports = [];
   for (const file of files) {
-    const stem = path20.basename(file).replace(/\.npz$/, "");
+    const stem = path21.basename(file).replace(/\.npz$/, "");
     try {
-      reports.push(analyzeTake(stem, await fs21.readFile(file), gates));
+      reports.push(analyzeTake(stem, await fs22.readFile(file), gates));
     } catch (err) {
       reports.push({
         take: stem,
@@ -20463,7 +20742,7 @@ async function motionCompile(opts, log) {
   let cfg = DEFAULT_MOTION_CONFIG;
   if (opts.configPath) {
     try {
-      const patch = JSON.parse(await fs21.readFile(opts.configPath, "utf8"));
+      const patch = JSON.parse(await fs22.readFile(opts.configPath, "utf8"));
       cfg = { ...DEFAULT_MOTION_CONFIG, ...patch, idleLoop: { ...DEFAULT_MOTION_CONFIG.idleLoop, ...patch.idleLoop } };
     } catch {
       log.error(`Couldn't read the --config JSON at ${opts.configPath}.`);
@@ -20481,16 +20760,16 @@ async function motionCompile(opts, log) {
   }
   const inputs = [];
   for (const file of files) {
-    const stem = path20.basename(file).replace(/\.npz$/, "");
+    const stem = path21.basename(file).replace(/\.npz$/, "");
     try {
-      inputs.push({ stem, take: loadTake(await fs21.readFile(file)) });
+      inputs.push({ stem, take: loadTake(await fs22.readFile(file)) });
     } catch (err) {
       log.error(`${stem}: ${err instanceof Error ? err.message : String(err)}`);
       process.exitCode = 1;
       return;
     }
   }
-  const setName = opts.set ?? path20.basename(opts.out).replace(/\.json$/, "");
+  const setName = opts.set ?? path21.basename(opts.out).replace(/\.json$/, "");
   let result;
   try {
     result = compileSet(inputs, setName, cfg);
@@ -20505,9 +20784,9 @@ async function motionCompile(opts, log) {
     process.exitCode = 1;
     return;
   }
-  await fs21.mkdir(path20.dirname(path20.resolve(opts.out)), { recursive: true });
+  await fs22.mkdir(path21.dirname(path21.resolve(opts.out)), { recursive: true });
   const json = JSON.stringify(result.data);
-  await fs21.writeFile(opts.out, json);
+  await fs22.writeFile(opts.out, json);
   if (opts.json) {
     writeJson({ out: opts.out, set: setName, tracks: Object.keys(result.data.gaits), bytes: json.length });
     return;
@@ -20525,9 +20804,9 @@ var MOTION_RUNTIME_FILES = [
 var MOTION_PRESETS = {
   rifle: ["sets/rifle.json", "sets/jumps.json"]
 };
-var MOTION_DEST = path20.join("src", "motion");
+var MOTION_DEST = path21.join("src", "motion");
 async function motionInstall(opts, log) {
-  const srcDir = path20.join(getTemplatesDir(), "motion");
+  const srcDir = path21.join(getTemplatesDir(), "motion");
   const root = opts.cwd ?? process.cwd();
   const preset = opts.set;
   if (preset !== void 0 && !MOTION_PRESETS[preset]) {
@@ -20538,21 +20817,21 @@ async function motionInstall(opts, log) {
   const files = [...MOTION_RUNTIME_FILES, ...preset ? MOTION_PRESETS[preset] : []];
   log.plain(c.bold(`genex motion install${preset ? ` --set ${preset}` : ""}`));
   log.plain("");
-  log.step(`Vendoring the motion runtime into ${c.cyan(MOTION_DEST + path20.sep)}`);
+  log.step(`Vendoring the motion runtime into ${c.cyan(MOTION_DEST + path21.sep)}`);
   let copied = 0, skipped = 0;
   try {
     for (const rel of files) {
-      const dest = path20.join(root, MOTION_DEST, rel);
-      const exists5 = await fs21.access(dest).then(() => true, () => false);
+      const dest = path21.join(root, MOTION_DEST, rel);
+      const exists5 = await fs22.access(dest).then(() => true, () => false);
       if (!opts.force && exists5) {
         skipped++;
-        log.dim(`  skipped ${path20.join(MOTION_DEST, rel)} (exists \u2014 use --force to overwrite)`);
+        log.dim(`  skipped ${path21.join(MOTION_DEST, rel)} (exists \u2014 use --force to overwrite)`);
         continue;
       }
-      await fs21.mkdir(path20.dirname(dest), { recursive: true });
-      await fs21.copyFile(path20.join(srcDir, rel), dest);
+      await fs22.mkdir(path21.dirname(dest), { recursive: true });
+      await fs22.copyFile(path21.join(srcDir, rel), dest);
       copied++;
-      log.dim(`  ${path20.join(MOTION_DEST, rel)}`);
+      log.dim(`  ${path21.join(MOTION_DEST, rel)}`);
     }
   } catch (err) {
     log.error(`Copy failed: ${String(err)}`);
@@ -20593,7 +20872,7 @@ async function motionConstraints(opts, log) {
   }
   const doc = directionConstraint(dir, speed, duration);
   const out = opts.out ?? "constraints.json";
-  await fs21.writeFile(out, JSON.stringify(doc));
+  await fs22.writeFile(out, JSON.stringify(doc));
   if (opts.json) {
     writeJson({ out, dir: dirName, speed, duration, waypoints: doc[0].frame_indices.length });
     return;
@@ -20630,14 +20909,14 @@ async function runMotion(opts) {
 }
 
 // src/commands/blender.ts
-import fs22 from "fs/promises";
-import path21 from "path";
+import fs23 from "fs/promises";
+import path22 from "path";
 var SUBS2 = ["demo", "exec", "snap", "scene", "import", "export", "reset", "mcp", "serve", "seat", "release"];
 var DEFAULT_OUT_DIR = "assets/blender";
 async function writeB64(dir, name, b64) {
-  await fs22.mkdir(dir, { recursive: true });
-  const p = path21.join(dir, name);
-  await fs22.writeFile(p, Buffer.from(b64, "base64"));
+  await fs23.mkdir(dir, { recursive: true });
+  const p = path22.join(dir, name);
+  await fs23.writeFile(p, Buffer.from(b64, "base64"));
   return p;
 }
 function reportScene(log, s) {
@@ -20663,7 +20942,7 @@ async function runBlender(opts) {
     return serveLocalBlender({ port, log });
   }
   if (sub === "mcp") {
-    const { runBlenderMcp } = await import("./blender-mcp-FQJFZETR.js");
+    const { runBlenderMcp } = await import("./blender-mcp-PWOUSXK4.js");
     return runBlenderMcp();
   }
   if (sub === "seat") {
@@ -20721,7 +21000,7 @@ async function runBlender(opts) {
     log.plain(rest.join("\n"));
     return 1;
   }
-  const outDir = path21.resolve(opts.outDir ?? DEFAULT_OUT_DIR);
+  const outDir = path22.resolve(opts.outDir ?? DEFAULT_OUT_DIR);
   const mode = opts.mode;
   if (mode !== void 0 && !isRenderMode(mode)) {
     log.error(`Unknown --mode ${mode}. Use one of: ${RENDER_MODES.join(", ")}.`);
@@ -20761,14 +21040,14 @@ async function runBlender(opts) {
       return 0;
     }
     case "export": {
-      const target = opts.out ?? path21.join(outDir, "scene.glb");
+      const target = opts.out ?? path22.join(outDir, "scene.glb");
       const r = await blenderCall(base, "/export", { path: "/tmp/genex-export.glb" });
       if (!r.glbBase64) {
         log.error(`/export answered with no GLB bytes${r.uploaded ? " (it was uploaded, not inlined)" : ""}`);
         return 1;
       }
-      await fs22.mkdir(path21.dirname(target), { recursive: true });
-      await fs22.writeFile(target, Buffer.from(r.glbBase64, "base64"));
+      await fs23.mkdir(path22.dirname(target), { recursive: true });
+      await fs23.writeFile(target, Buffer.from(r.glbBase64, "base64"));
       log.success(`Exported ${r.bytes ?? 0} bytes`);
       log.plain(`  ${c.cyan(target)}`);
       return 0;
@@ -20801,12 +21080,12 @@ async function runBlender(opts) {
           return 1;
         }
         try {
-          script = await fs22.readFile(opts.input, "utf8");
+          script = await fs23.readFile(opts.input, "utf8");
         } catch {
           log.error(`Can't read ${opts.input}`);
           return 1;
         }
-        label = path21.basename(opts.input);
+        label = path22.basename(opts.input);
       }
       const r = await blenderCall(base, "/exec", { script, ...mode ? { mode } : {}, sheet: { formats: SHEET_FORMATS } });
       if (r.stdout?.trim()) log.plain(r.stdout.trimEnd());
@@ -20925,9 +21204,9 @@ print(f"castle: {n} objects")
 `;
 
 // src/commands/asset-new.ts
-import fs23 from "fs";
+import fs24 from "fs";
 import fsp from "fs/promises";
-import path22 from "path";
+import path23 from "path";
 import { pathToFileURL } from "url";
 var EXTRA_FILES = [
   "genex-asset.example.json",
@@ -21021,7 +21300,7 @@ Every milestone ends with \`npm run verify\`, then \`npx genex preview --no-buil
 }
 async function runAssetNew(options) {
   const log = createLogger();
-  const cwd = options.dir ? path22.resolve(options.dir) : process.cwd();
+  const cwd = options.dir ? path23.resolve(options.dir) : process.cwd();
   const slug = options.assetSlug;
   if (!slug) {
     log.error('Usage: genex asset new <slug> [--title "<Name>"] [--dims WxDxH] [--tri-band LOW-HIGH] [--holder "<your name>"] [--out <dir>]');
@@ -21031,14 +21310,14 @@ async function runAssetNew(options) {
     log.error(`The slug must be kebab-case (letters, digits, dashes), got: ${slug}`);
     return 1;
   }
-  const templateDir = path22.join(getTemplatesDir(), "asset-viewer");
-  if (!fs23.existsSync(templateDir)) {
+  const templateDir = path23.join(getTemplatesDir(), "asset-viewer");
+  if (!fs24.existsSync(templateDir)) {
     log.error(`Vendored asset-viewer template not found at ${templateDir} \u2014 reinstall the CLI.`);
     return 1;
   }
-  const manifestTools = await import(pathToFileURL(path22.join(templateDir, "tools", "emit-manifest.mjs")).href);
+  const manifestTools = await import(pathToFileURL(path23.join(templateDir, "tools", "emit-manifest.mjs")).href);
   const { SHARED_FILES, PARITY_FILENAME, hashSharedFiles, pascalCase } = manifestTools;
-  const lockPath = path22.join(templateDir, "shared-files.sha256.json");
+  const lockPath = path23.join(templateDir, "shared-files.sha256.json");
   const lock = JSON.parse(await fsp.readFile(lockPath, "utf8"));
   const actual = hashSharedFiles(templateDir);
   const drifted = SHARED_FILES.filter((rel) => lock.files[rel] !== actual[rel]);
@@ -21051,8 +21330,8 @@ async function runAssetNew(options) {
   const triBand = parseBand(options.triBand ?? "500-8000");
   const holder = options.holder?.trim() || HOLDER_PLACEHOLDER;
   const year = (/* @__PURE__ */ new Date()).getUTCFullYear();
-  const outDir = path22.resolve(cwd, options.out ?? slug);
-  if (fs23.existsSync(outDir) && fs23.readdirSync(outDir).length > 0 && !options.force) {
+  const outDir = path23.resolve(cwd, options.out ?? slug);
+  if (fs24.existsSync(outDir) && fs24.readdirSync(outDir).length > 0 && !options.force) {
     log.error(`${outDir} already holds files. Nothing was touched \u2014 pass --force to write into it anyway.`);
     return 1;
   }
@@ -21080,24 +21359,24 @@ async function runAssetNew(options) {
   };
   await fsp.mkdir(outDir, { recursive: true });
   for (const rel of [...SHARED_FILES, ...EXTRA_FILES]) {
-    const to = path22.join(outDir, rel);
-    await fsp.mkdir(path22.dirname(to), { recursive: true });
-    await fsp.copyFile(path22.join(templateDir, rel), to);
+    const to = path23.join(outDir, rel);
+    await fsp.mkdir(path23.dirname(to), { recursive: true });
+    await fsp.copyFile(path23.join(templateDir, rel), to);
   }
-  const pkg = fillTemplate(await fsp.readFile(path22.join(templateDir, "package.json"), "utf8"), {
+  const pkg = fillTemplate(await fsp.readFile(path23.join(templateDir, "package.json"), "utf8"), {
     slug,
     name,
     version
   });
-  await fsp.writeFile(path22.join(outDir, "package.json"), pkg, "utf8");
-  await fsp.writeFile(path22.join(outDir, "asset.config.json"), JSON.stringify(config, null, 2) + "\n", "utf8");
-  await fsp.writeFile(path22.join(outDir, ".gitignore"), GITIGNORE, "utf8");
+  await fsp.writeFile(path23.join(outDir, "package.json"), pkg, "utf8");
+  await fsp.writeFile(path23.join(outDir, "asset.config.json"), JSON.stringify(config, null, 2) + "\n", "utf8");
+  await fsp.writeFile(path23.join(outDir, ".gitignore"), GITIGNORE, "utf8");
   await fsp.writeFile(
-    path22.join(outDir, "DESIGN.md"),
+    path23.join(outDir, "DESIGN.md"),
     designDoc({ name, slug, sizeMeters, triBand, holder }),
     "utf8"
   );
-  const placeholder = await fsp.readFile(path22.join(templateDir, "src", "asset", "PLACEHOLDER.ts"), "utf8");
+  const placeholder = await fsp.readFile(path23.join(templateDir, "src", "asset", "PLACEHOLDER.ts"), "utf8");
   const seeded = seedAssetSource(placeholder, {
     slug,
     name,
@@ -21108,8 +21387,8 @@ async function runAssetNew(options) {
     pascalCase
   });
   const assetFilename = `${slug.replace(/-([a-z0-9])/g, (_, ch) => ch.toUpperCase())}.ts`;
-  await fsp.mkdir(path22.join(outDir, "src", "asset"), { recursive: true });
-  await fsp.writeFile(path22.join(outDir, "src", "asset", assetFilename), seeded, "utf8");
+  await fsp.mkdir(path23.join(outDir, "src", "asset"), { recursive: true });
+  await fsp.writeFile(path23.join(outDir, "src", "asset", assetFilename), seeded, "utf8");
   const copied = hashSharedFiles(outDir);
   const mismatched = SHARED_FILES.filter((rel) => copied[rel] !== lock.files[rel]);
   if (mismatched.length) {
@@ -21117,7 +21396,7 @@ async function runAssetNew(options) {
     return 1;
   }
   await fsp.writeFile(
-    path22.join(outDir, PARITY_FILENAME),
+    path23.join(outDir, PARITY_FILENAME),
     JSON.stringify(
       {
         note: "Recorded by `genex asset new`. Gate G13 recomputes these; do not hand-edit the viewer.",
@@ -21161,11 +21440,11 @@ async function runAssetNew(options) {
 }
 
 // src/commands/tools.ts
-import path25 from "path";
+import path26 from "path";
 
 // src/lib/local-install.ts
-import fs24 from "fs/promises";
-import path23 from "path";
+import fs25 from "fs/promises";
+import path24 from "path";
 import { spawn as spawn4 } from "child_process";
 var CLI_PACKAGE = "@genex-ai/cli-demo";
 var FULL_NAME_FALLBACK = `npx ${CLI_PACKAGE}@${CLI_CHANNEL}`;
@@ -21178,17 +21457,17 @@ var LOCKFILES = [
 ];
 async function exists4(p) {
   try {
-    await fs24.access(p);
+    await fs25.access(p);
     return true;
   } catch {
     return false;
   }
 }
 async function detectPackageManager(cwd) {
-  let dir = path23.resolve(cwd);
+  let dir = path24.resolve(cwd);
   for (; ; ) {
     try {
-      const raw = await fs24.readFile(path23.join(dir, "package.json"), "utf8");
+      const raw = await fs25.readFile(path24.join(dir, "package.json"), "utf8");
       const pm = JSON.parse(raw).packageManager;
       if (typeof pm === "string") {
         const name = pm.split("@")[0];
@@ -21197,18 +21476,18 @@ async function detectPackageManager(cwd) {
     } catch {
     }
     for (const [file, pm] of LOCKFILES) {
-      if (await exists4(path23.join(dir, file))) return pm;
+      if (await exists4(path24.join(dir, file))) return pm;
     }
-    const parent = path23.dirname(dir);
+    const parent = path24.dirname(dir);
     if (parent === dir) return "npm";
     dir = parent;
   }
 }
 async function findLocalCli(cwd) {
-  let dir = path23.resolve(cwd);
+  let dir = path24.resolve(cwd);
   for (; ; ) {
-    if (await exists4(path23.join(dir, "node_modules", CLI_PACKAGE, "package.json"))) return dir;
-    const parent = path23.dirname(dir);
+    if (await exists4(path24.join(dir, "node_modules", CLI_PACKAGE, "package.json"))) return dir;
+    const parent = path24.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -21226,7 +21505,7 @@ function installArgs(pm, spec) {
   }
 }
 function manifestName(cwd) {
-  const slug = path23.basename(path23.resolve(cwd)).toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 100);
+  const slug = path24.basename(path24.resolve(cwd)).toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 100);
   return slug || "genex-tools-workspace";
 }
 function isSourceRun(moduleUrl = import.meta.url) {
@@ -21284,10 +21563,10 @@ async function ensureLocalCli(log, cwd = process.cwd(), opts = {}) {
     return;
   }
   const pm = await detectPackageManager(cwd);
-  const hadManifest = await exists4(path23.join(cwd, "package.json"));
+  const hadManifest = await exists4(path24.join(cwd, "package.json"));
   if (!hadManifest) {
-    await fs24.writeFile(
-      path23.join(cwd, "package.json"),
+    await fs25.writeFile(
+      path24.join(cwd, "package.json"),
       JSON.stringify({ name: manifestName(cwd), private: true }, null, 2) + "\n"
     );
     await ensureIgnored(cwd, "node_modules/");
@@ -21307,20 +21586,20 @@ async function ensureLocalCli(log, cwd = process.cwd(), opts = {}) {
   }
 }
 async function ensureIgnored(dir, entry) {
-  const file = path23.join(dir, ".gitignore");
+  const file = path24.join(dir, ".gitignore");
   let content = "";
   try {
-    content = await fs24.readFile(file, "utf8");
+    content = await fs25.readFile(file, "utf8");
   } catch {
   }
   if (content.split("\n").some((l) => l.trim() === entry)) return;
   let next = content;
   if (next.length > 0 && !next.endsWith("\n")) next += "\n";
-  await fs24.writeFile(file, next + entry + "\n");
+  await fs25.writeFile(file, next + entry + "\n");
 }
 
 // src/commands/doctor.ts
-import path24 from "path";
+import path25 from "path";
 var LANE_ORDER = [
   "model",
   "image",
@@ -21601,7 +21880,7 @@ async function fetchLegalStatus(apiUrl, token) {
 }
 async function firstSkillsMarker() {
   for (const target of resolveAgentTargets()) {
-    const marker = await readSkillsMarker(path24.join(target.baseDir, "skills"));
+    const marker = await readSkillsMarker(path25.join(target.baseDir, "skills"));
     if (marker) return marker;
   }
   return null;
@@ -21640,8 +21919,8 @@ async function runTools(opts) {
   let totalNew = 0;
   let totalUpdated = 0;
   for (const t of targets) {
-    const dest = path25.join(t.baseDir, "skills");
-    const { copied, updated } = await copyTemplates(path25.join(templatesDir, "skills"), dest, {
+    const dest = path26.join(t.baseDir, "skills");
+    const { copied, updated } = await copyTemplates(path26.join(templatesDir, "skills"), dest, {
       filter: (rel) => skillFamilyFilter("tools")(`skills/${rel}`)
     });
     await pruneRemovedSkills(dest, log);
@@ -21702,7 +21981,7 @@ async function runTools(opts) {
 // src/lib/costs.ts
 var TYPICAL_CREDITS = {
   model: 35,
-  // 46 from a reference image
+  // 46 from a reference image; --texture standard 23, --no-texture 12, --geometry detailed 58, --quad 41, --low-poly 46, --parts 58 quote off the estimate
   image: 4,
   // gpt-image-2 tiers (--transparent, --quality high, --edit, 4K) quote higher
   texture: 5,
@@ -21717,17 +21996,22 @@ var TYPICAL_CREDITS = {
   model_rig: 29,
   model_animation: 12,
   // PER CLIP — `--preset walk,run` quotes ceil(2 × 10¢ × 1.15)
-  character: 58,
+  character: 64,
+  // one-shot on Meshy 7 Ultra at 4k with the controller pack; `genex creature` (no pack) 46, --no-ultra 58, --texture 8k 69
   character_concept: 32,
   character_preview: 41,
+  // Meshy 7 Ultra at 4k; --no-ultra 35, --texture 8k 46
   character_finalize: 29,
   character_animation: 6,
   character_motion: 46,
   // one text-route clip; other routes are priced off their own cost
-  character_rerig: 12
+  character_rerig: 12,
+  character_import: 18
+  // Uthana auto-rig of your own GLB; the upload itself is free
 };
 
 // src/index.ts
+var TEXTURE_FLAG_VALUES = ["standard", "detailed", "none", "2k", "4k", "8k"];
 var MODEL_SUB_SET = new Set(MODEL_SUBCOMMANDS);
 var GEN_KINDS = /* @__PURE__ */ new Set(["model", "skybox", "sfx", "music", "voice", "texture", "image", "video"]);
 var HELP = `${c.bold("genex")} \u2014 set up your project's agent workspace, authorize, and publish 3D games.
@@ -21804,7 +22088,11 @@ ${c.bold("Usage")}
                                      default, and --no-resellable turns it back off.
   genex model "<prompt>" [options]   Generate a 3D model (GLB); prints a public asset URL.
                                      --image <path|url> builds it FROM a reference
-                                     image instead (prompt optional).
+                                     image instead (prompt optional). Quality knobs:
+                                     --texture standard|detailed|none, --geometry
+                                     detailed, --quad, --low-poly, --parts,
+                                     --face-limit <n>, --auto-size (each is priced
+                                     in the quote).
   genex model segment <id>           Split a generated model into NAMED parts \u2014
                                      one GLB, parts addressable by name (doors,
                                      magazines, turrets, destructibles).
@@ -21814,6 +22102,10 @@ ${c.bold("Usage")}
                                      avian|serpentine|aquatic). Auto-detects the
                                      plan; --type picks it explicitly. Unriggable
                                      meshes are refused and auto-refunded.
+  genex model import <file.glb>      Bring in a mesh you already have (a Blender
+                                     export, a bought asset) as a model of yours \u2014
+                                     free, \u226464 MB \u2014 so rig/animate/segment, blender
+                                     import and "Use in game" all work on it.
   genex model animate <rig-id> --preset walk[,run,\u2026]
                                      Retarget ready-made motion clips onto a
                                      'model rig' result (billed per clip).
@@ -21853,6 +22145,12 @@ ${c.bold("Usage")}
                                      can take new animations. With no id it adopts the
                                      body this game already wears. Free \u2014 it copies,
                                      it does not generate.
+  genex character import <file.glb>  Your own humanoid mesh, auto-rigged by Uthana
+                                     (finger joints included; --no-fingers skips
+                                     them; --height <m>). \u226430 MB, biped, T- or
+                                     A-pose. Then 'character animate <id>
+                                     --locomotion' \u2014 the Meshy catalog and pack do
+                                     not apply to a Uthana rig.
   genex creature "<desc>"            One-shot rigged enemy/creature (biped-shaped
                                      bodies only \u2014 Meshy rig limit): model \u2192 rig \u2192
                                      bind library clips via --animation. No approval
@@ -21914,6 +22212,14 @@ ${c.bold("Options for the generators (`model` `sfx` `music` `voice` `texture` `i
   --image <path|url>   (model) build the model FROM this reference image \u2014 a
                        local file (\u22644 MB, inlined) or a previous generation's
                        asset URL. The prompt becomes optional.
+  --texture <tier>     (model) standard | detailed (default) | none \u2014 detailed is
+                       +10 credits over standard, none is geometry only.
+  --geometry <tier>    (model) standard (default) | detailed (+20 credits, hero pieces).
+  --quad               (model) quad-dominant mesh (+5; face limit \u2264150000).
+  --low-poly           (model) smart low-poly topology (+10) \u2014 game-ready meshes.
+  --parts              (model) separated, named parts at generation (+20).
+  --face-limit <n>     (model) cap on the raw mesh, 1000-2000000 (default 150000).
+  --auto-size          (model) scale to real-world metres by AI estimate.
   --granularity <g>    (model segment) part granularity: simple | balanced |
                        detailed (default balanced).
   --type <plan>        (model rig) body plan: biped | quadruped | hexapod |
@@ -22060,13 +22366,23 @@ ${c.bold("Options for `character` / `animations search`")}
                        ranked action IDs instead of choosing silently.
   --candidate <1|2|3>  (character preview) selected concept candidate.
   --user-approved      Confirm the user explicitly approved the candidate/preview.
-  --approve-remesh 10000
-                       (character finalize) approve the separate 10,000-face rigging copy.
-  --direct-text        Compatibility path: skip concept/preview approval and generate
+  --approve-remesh <faces>
+                       (character finalize) approve the separate rigging copy at this
+                       face budget, 10000-100000 (10000 for a crowd body, 30000+ for a
+                       hero). The number IS the approval.
+  --direct-text        One-shot path: skip concept/preview approval and generate
                        directly from text (defaults to a 10,000-face target).
   --no-controller-pack (character --direct-text only) skip the validated locomotion pack.
   --height <meters>    (character) target character height, 0.5-3 meters.
-  --polycount <count>  (character --direct-text only) target 10000-100000 polygons.
+  --polycount <count>  (character --direct-text / creature) target 10000-100000 polygons.
+  --texture <res>      (character/creature/preview) texture size 2k | 4k (default) | 8k
+                       (+5 credits). Meshy 7 on every lane.
+  --no-ultra           (character/creature/preview) skip Meshy Ultra (\u22125 credits, less
+                       surface detail).
+  --pose <a-pose|t-pose>
+                       (character --direct-text / creature) preferred rest pose; the
+                       other stays the QA fallback.
+  --no-fingers         (character import) skip finger joints in the Uthana rig.
   --no-wait            (character/preview/finalize/animate) enqueue and return a generation id.
   --json               Emit one machine-readable workflow result object.
   --action <id|query>  (character animate) action to add; repeatable.
@@ -22324,6 +22640,13 @@ function parseArgs(argv) {
     "--image",
     "--granularity",
     "--preset",
+    // Quality knobs (2026-09-06): `--texture` is shared by `model`
+    // (standard|detailed|none) and the character lanes (2k|4k|8k); each command
+    // re-validates its own vocabulary client-side.
+    "--texture",
+    "--geometry",
+    "--face-limit",
+    "--pose",
     // `genex blender` (M1 spike): which shading the contact sheet uses.
     "--mode",
     // `genex ui` string flags (the numeric ones come from UI_NUMBER_FLAGS).
@@ -22407,6 +22730,24 @@ function parseArgs(argv) {
       case "--no-controller-pack":
         parsed.options.controllerPack = false;
         break;
+      case "--no-fingers":
+        parsed.options.fingers = false;
+        break;
+      case "--no-ultra":
+        parsed.options.ultra = false;
+        break;
+      case "--quad":
+        parsed.options.quad = true;
+        break;
+      case "--low-poly":
+        parsed.options.lowPoly = true;
+        break;
+      case "--parts":
+        parsed.options.parts = true;
+        break;
+      case "--auto-size":
+        parsed.options.autoSize = true;
+        break;
       case "--user-approved":
         parsed.options.userApproved = true;
         break;
@@ -22527,7 +22868,9 @@ function parseArgs(argv) {
             parsed.options.conceptId = arg;
           } else if (parsed.options.name === "finalize" && !parsed.options.previewId) {
             parsed.options.previewId = arg;
-          } else if (!["animate", "motions", "preview", "finalize", "adopt"].includes(parsed.options.name ?? "")) {
+          } else if (parsed.options.name === "import" && !parsed.options.importPath) {
+            parsed.options.importPath = arg;
+          } else if (!["animate", "motions", "preview", "finalize", "adopt", "import"].includes(parsed.options.name ?? "")) {
             parsed.options.name = `${parsed.options.name} ${arg}`;
           } else {
             parsed.error = `Unexpected argument: ${arg}`;
@@ -22678,8 +23021,8 @@ function applyValueFlag(options, flag, value) {
     }
     case "--approve-remesh": {
       const n = Number(value);
-      if (!Number.isInteger(n) || n !== 1e4) {
-        throw new Error(`Invalid --approve-remesh value: ${value} (expected exactly 10000)`);
+      if (!Number.isInteger(n) || n < REMESH_TARGET_MIN || n > REMESH_TARGET_MAX) {
+        throw new Error(`Invalid --approve-remesh value: ${value} (expected ${REMESH_TARGET_MIN}-${REMESH_TARGET_MAX} faces)`);
       }
       options.approveRemesh = n;
       break;
@@ -22847,6 +23190,32 @@ function applyValueFlag(options, flag, value) {
     case "--image":
       options.imageUrl = value;
       break;
+    case "--texture":
+      if (!TEXTURE_FLAG_VALUES.includes(value)) {
+        throw new Error(`Invalid --texture value: ${value} (model: standard|detailed|none; character: 2k|4k|8k)`);
+      }
+      options.texture = value;
+      break;
+    case "--geometry":
+      if (value !== "standard" && value !== "detailed") {
+        throw new Error(`Invalid --geometry value: ${value} (expected standard|detailed)`);
+      }
+      options.geometry = value;
+      break;
+    case "--face-limit": {
+      const n = Number(value);
+      if (!Number.isInteger(n) || n < 1e3 || n > 2e6) {
+        throw new Error(`Invalid --face-limit value: ${value} (expected 1000-2000000)`);
+      }
+      options.faceLimit = n;
+      break;
+    }
+    case "--pose":
+      if (value !== "a-pose" && value !== "t-pose") {
+        throw new Error(`Invalid --pose value: ${value} (expected a-pose|t-pose)`);
+      }
+      options.pose = value;
+      break;
     case "--granularity":
       options.granularity = value;
       break;
@@ -22966,6 +23335,7 @@ async function main() {
       if (parsed.command === "model" && MODEL_SUB_SET.has(parsed.options.name ?? "")) {
         if (parsed.options.name === "segment") await runModelSegment(parsed.options);
         else if (parsed.options.name === "rig") await runModelRig(parsed.options);
+        else if (parsed.options.name === "import") await runModelImport(parsed.options);
         else await runModelAnimate(parsed.options);
         return;
       }
@@ -23031,6 +23401,8 @@ async function main() {
           await runCharacterFinalize(parsed.options);
         } else if (parsed.options.name === "adopt") {
           await runCharacterAdopt(parsed.options);
+        } else if (parsed.options.name === "import") {
+          await runCharacterImport(parsed.options);
         } else {
           await runCharacter({ ...parsed.options, prompt: parsed.options.name });
         }