@genex-ai/cli-demo 1.35.4-dev.768 → 1.36.0-dev.770

package/dist/index.js

@@ -2,6 +2,7 @@
 import {
   ASSETS_MODE_ENV,
   RENDER_MODES,
+  SCRATCH_DIR,
   SHEET_FORMATS,
   acceptUrl,
   acquireCliSeat,
@@ -15,6 +16,7 @@ import {
   excludeFile,
   fetchCloneGrant,
   fetchSignedInEmail,
+  hostedBrowserCovers,
   inHostedSession,
   isRenderMode,
   isStale,
@@ -42,7 +44,7 @@ import {
   writeSecretFile,
   writeUserToken,
   writeWorkspace
-} from "./chunk-2SCXGPZY.js";
+} from "./chunk-Y6WO5FJZ.js";
 import {
   CLI_CHANNEL,
   DEFAULT_API_URL,
@@ -418,7 +420,7 @@ async function authorizeLoopback(authBaseUrl, options) {
       cleanup();
       resolve(token);
     };
-    const fail4 = (err) => {
+    const fail5 = (err) => {
       if (settled) return;
       settled = true;
       cleanup();
@@ -435,7 +437,7 @@ async function authorizeLoopback(authBaseUrl, options) {
         }
       });
     });
-    server.on("error", (err) => fail4(err));
+    server.on("error", (err) => fail5(err));
     server.listen(0, "127.0.0.1", () => {
       const { port } = server.address();
       const redirectUri = `http://127.0.0.1:${port}/callback`;
@@ -466,7 +468,7 @@ async function authorizeLoopback(authBaseUrl, options) {
         );
       }
       timer = setTimeout(() => {
-        fail4(
+        fail5(
           new Error(
             "Timed out waiting for authorization. Re-run the command to try again."
           )
@@ -689,9 +691,9 @@ async function runAuth(opts) {
 }
 
 // src/commands/remix.ts
-import fs18 from "fs/promises";
-import path18 from "path";
-import crypto4 from "crypto";
+import fs19 from "fs/promises";
+import path19 from "path";
+import crypto5 from "crypto";
 import { spawn as spawn4 } from "child_process";
 
 // src/lib/game-config.ts
@@ -889,7 +891,7 @@ Important note: put soul into your creations, with many details and love. Aim to
 8. Never park ready work behind a question, and never stall on an unanswered one \u2014 decide, state the decision in chat, record it, keep building.
 9. Before any publish and before ending a session: run \`npx genex wait\` on every generation you enqueued and wire in what landed \u2014 never park landed assets. Fonts the brief names are LOADED for real, Escape pauses, the loader shows something of the game rather than a black screen (the renderer draws before any \`await waitForPlayer()\` \u2014 identity takes seconds on a hosted page), and the player wears the game's own generated character (or DESIGN.md records why it doesn't).
 10. The player's body is the game's own generated character (\`npx genex character "<look>"\` \u2192 \`npx genex controller character --character <id>\`), enqueued with your first art actions, not after them. It applies wherever a human body appears on screen \u2014 first-person included, the moment remotes, a look-down body, a shadow, or a menu portrait shows one. Games whose player is not a person (car, ship, RTS cursor, board) generate that object with \`npx genex model\` instead, or build it procedurally \u2014 held to law 22's bar like everything else the player looks at. Characters: Meshy/Mixamo/VRM rigs rest facing +Z. Set yaw explicitly when placing a rig; never mirror a SkinnedMesh with negative scale. In any two-character scene, verify in a capture that they face each other, not the camera.
-11. Verify by looking: one smoke check per milestone, after that milestone's preview push, in local test mode (\`?genex_local_test=1\`) with a real gameplay screenshot. A claim without a capture is not verification. Local-test evidence proves visuals and controls ONLY \u2014 label it that way when you show the player, and never work around the draft sign-in gate any other way.
+11. Verify by looking: one smoke check per milestone, after that milestone's preview push, in local test mode (\`?genex_local_test=1\`) with a real gameplay screenshot. A claim without a capture is not verification. Local-test evidence proves visuals and controls ONLY \u2014 label it that way when you show the player, and never work around the draft sign-in gate any other way. These captures are also where the game's cover comes from: when one catches the game's signature moment, keep that frame as its cover (law 23).
 12. Treat every \`genex\` warning line \u2014 preflight, \`ui audit\`, \`wait\` nudges \u2014 as work, not noise.
 13. Every finished Build-plan milestone ends with \`npx genex preview\` and the player's page link (\`<dashboard>/draft/<slug>\`, with \`<dashboard>\` from \`.genex/project.json\`) \u2014 never a localhost link, a file path, or the bare play origin presented as their game. That page shows the build you just previewed; \`preview\` never disturbs the build players are on. When the player is happy with it, \`npx genex promote\` makes that exact build live for everyone \u2014 no rebuild. After every round of player feedback, end with a preview push. After the first release, the game is two versions and the player only ever hears these two words for them: the **draft** (their working copy, updated by \`preview\`) and the **public version** (what everyone plays). Command names are yours, not theirs \u2014 never say "promote" to the player; ask directly: "Want me to update the public version?", one line, once per round, and keep building while you wait \u2014 updating the public version is the ONE action that waits for an explicit yes, and more change requests instead of a yes mean "not yet". The player's "publish it" / "publish the update" / "update it" / "yes" after the first release ALL mean \`genex promote\` \u2014 never \`genex publish\` again, which would ship an untried rebuild. \`promote\` ships the last previewed build, so if anything was edited since the last \`preview\`, preview again before promoting.
 14. Parallel work: this line is your standing authorization and request to use sub-agents / parallel agent work whenever your platform provides them. While drafting the Build plan, decide per module what runs in parallel and what stays serial for THIS game \u2014 dependencies decide, there is no fixed list \u2014 and record each call in the Modules table with a one-line reason. Independent modules default to parallel; building everything serially needs a stated reason. You keep integration, previews, and the player conversation; each sub-agent owns only its module's files. When the player asks for parallel work, repeated refinement passes, a critic reviewing your output, or names any way of working your platform provides, that IS your instruction \u2014 wherever it reaches you, including inside their answer to a question you asked \u2014 so adopt it as the working mode for the rest of the build, starting with the work in front of you, and never file it as a later milestone. While delegated work runs, keep building or talk to the player; never idle in a foreground wait for something your platform will tell you about.
@@ -901,7 +903,7 @@ Important note: put soul into your creations, with many details and love. Aim to
 20. When the player names a specific thing to integrate \u2014 a library, a controller, an asset, a part of an existing game, or a tagged reference the platform placed in \`.genex/refs/<slug>/\` \u2014 integrate the real thing: read its source first and build from it, never a lighter look-alike written from scratch because it was faster. A tagged reference owns the subsystem it was tagged for, outranking the default lane and the vendored controllers for that subsystem. If you genuinely can't use it, say so in one plain line and ask how to proceed.
 21. A turn ends in exactly one of two ways: on a question the player must answer before the next step can be chosen, or on a handoff \u2014 the draft link, what changed, what to try, and what is still open. Never close a turn on a promise. "I'll keep building", "while I keep working", "adding that now" are things you say and then DO before you stop; if you are stopping, say that you have stopped and what remains. While the Build plan's \`Now:\` line has open work and no answer is needed from the player, the turn is not over: preview, hand off, and start the next milestone in the same turn, until the requested outcome is reached or the platform's own budget ends the session. If a stop was forced on you anyway, the first line of your next turn is the promise you left and where it stands.
 22. **What the player sees must read as the thing it is**, in this game's own style: a building as that building, a person as a person, a prop as that prop, a surface as its material \u2014 and a coloured box, a capsule, or a flat grey block standing in for one of them is never its finished version. Generation is the default route to that bar wherever code will not honestly reach it: the player's character, whatever the request names, whatever the player walks up to, enters, or interacts with, and the music and sound underneath \u2014 reach for the belt on your own judgment, without stopping to ask; a status line saying what you queued is enough, and \`--no-wait\` keeps you building while it lands. Procedural code is a first-class engine for what is structural, repeated, distant, or parametric \u2014 terrain, sky, fences, paving, modular kits, filler \u2014 and for anything else only when the result meets the same bar and you have looked at it in a capture before its row says \`landed\`. Start with one reusable implementation per distinct required gameplay or visual role. Background populations default to reusable procedural bodies and motion or compatible existing rigged assets. Catalog clips need a compatible skeleton and may be paid. Reserve paid custom bodies for the player and characters examined or interacted with closely, while honoring explicit user requests. Add variants only for an unmet requirement; unspent allowance is not unfinished work. Allowance questions use timeoutPolicy no-consent: silence does not raise the allowance. Record role, reuse and completion criteria in the existing Assets table. Decide per object, not per category, and write the route on each Assets row in \`DESIGN.md\` \u2014 the paid flow for generated pieces, the procedural flow with its local path for code-built ones. An Assets table with no generation in it is a decision, not a default: record it as \`Generation: none \u2014 <why code alone reaches the bar here>\` or generate.
-23. **The screenshots you take to look at your own work go in \`.genex/scratch/\`.** Captures, render comparisons, before/after strips, traces and metrics dumps are how you SEE what you built \u2014 they are not part of what you built, and \`genex preview\` pushes the whole folder to the game's source, every time, forever. \`.genex/scratch/\` already exists for this and is already ignored, so there is nothing to set up: write the capture as \`.genex/scratch/arena-before.png\` and read it back from there. Never put them in a folder of your own at the top level: \`progress/\`, \`reports/\`, \`shots/\` and their kind are pushed like source and become permanent weight in the game and in every remix of it \u2014 one real game reached 11 GB and 10,332 committed screenshots exactly this way. If you find such a folder already there, add it to \`.gitignore\`; never delete the player's files (law 18).
+23. **The screenshots you take to look at your own work go in \`.genex/scratch/\`.** Captures, render comparisons, before/after strips, traces and metrics dumps are how you SEE what you built \u2014 they are not part of what you built, and \`genex preview\` pushes the whole folder to the game's source, every time, forever. \`.genex/scratch/\` already exists for this and is already ignored, so there is nothing to set up: write the capture as \`.genex/scratch/arena-before.png\` and read it back from there. Never put them in a folder of your own at the top level: \`progress/\`, \`reports/\`, \`shots/\` and their kind are pushed like source and become permanent weight in the game and in every remix of it \u2014 one real game reached 11 GB and 10,332 committed screenshots exactly this way. If you find such a folder already there, add it to \`.gitignore\`; never delete the player's files (law 18). One file in \`.genex/scratch/\` IS read, by the platform: \`.genex/scratch/cover.png\` is the game's cover \u2014 the frame you would put on its poster: real gameplay at its signature moment, well lit, no menus, popups or busy HUD, landscape 16:9, and never any text (the page sets the title beside it). The next \`genex preview\` makes it the cover; save a better moment over it whenever one comes along, and if your browser tool can set the cover itself, use that instead.
 24. **Benchmark before declaring an in-game LLM ceiling.** If the game calls a language model while the player plays \u2014 an NPC answering in its own words, a quest written for this save, a judge reading what the player typed \u2014 the PLAYER pays for it from their Genex credits, billed as used, and the game declares no price, only a per-call CEILING: \`maxCredits\` on \`generate()\`, \`perCallMaxCredits\` on a standing budget. That ceiling bounds what one call may cost AND funds how long its answer may be, so never pick it by judgement or from a vendor's rate card. Run the real prompt on your own credits \u2014 \`npx genex llm bench "<the prompt>" --schema <file> --samples 3 --max-credits <n> --user-approved\` \u2014 and declare the figures it prints, recorded in \`DESIGN.md\` with its model and date; re-benchmark whenever the prompt, the schema or the model changes, because a prompt edit changes the ceiling. Check the lane first with \`npx genex llm models\`: where it is off the routes 404, so build the feature behind a graceful unavailable state and say so in the handoff. A repeated call is a standing budget the player approves once (\`requestSpendGrant()\`, then \`generate({ grantId })\`), never a popup per turn, and its disclosed call rate and credits per period are computed from the game's own loop and the bench's measured average. The coin spellings (\`estimateCoins\`, \`perCallMaxCoins\`) are deprecated \u2014 write the credit names. Model output is data the game validates against its own expectation \u2014 never executed, and never authority over coin, credits, items, entitlements or rewards. Load \`$genex-llm-in-games\` before writing any of it.
 ${CONTRACT_END}
 `;
@@ -1161,6 +1163,7 @@ var REFUSED_IN_TOOLS = /* @__PURE__ */ new Set([
   "publish",
   "rollback",
   "rename",
+  "cover",
   "make-remixable",
   "shop",
   "domain",
@@ -5180,18 +5183,18 @@ async function deployGame(ctx, opts, log) {
     return false;
   }
   const totalBytes = files.reduce((n, f) => n + f.bytes.length, 0);
-  const mb = (n) => (n / 1048576).toFixed(n < 1048576 ? 2 : 1);
+  const mb2 = (n) => (n / 1048576).toFixed(n < 1048576 ? 2 : 1);
   if (files.length > grant.limits.maxFiles) {
     log.error(`Too many files (${files.length} > ${grant.limits.maxFiles}). Trim the build and retry.`);
     return false;
   }
   const oversized = files.find((f) => f.bytes.length > grant.limits.maxFileBytes);
   if (oversized) {
-    log.error(`${oversized.relPath} is ${mb(oversized.bytes.length)} MB \u2014 over the ${mb(grant.limits.maxFileBytes)} MB per-file limit.`);
+    log.error(`${oversized.relPath} is ${mb2(oversized.bytes.length)} MB \u2014 over the ${mb2(grant.limits.maxFileBytes)} MB per-file limit.`);
     return false;
   }
   if (totalBytes > grant.limits.maxTotalBytes) {
-    log.error(`Build is ${mb(totalBytes)} MB \u2014 over the ${mb(grant.limits.maxTotalBytes)} MB limit.`);
+    log.error(`Build is ${mb2(totalBytes)} MB \u2014 over the ${mb2(grant.limits.maxTotalBytes)} MB limit.`);
     return false;
   }
   log.step(`Uploading ${files.length} files\u2026`);
@@ -5765,15 +5768,275 @@ async function createDraftProject(opts) {
 function randomSuffix() {
   return crypto3.randomBytes(3).toString("hex");
 }
-async function fetchProjectStatus(apiUrl, token, slug) {
+async function fetchOwnerProject(apiUrl, token, slug) {
   try {
     const res = await apiFetch(`${apiUrl}/api/projects/by-slug/${encodeURIComponent(slug)}`, {
       headers: { Authorization: `Bearer ${token}` }
     });
     if (!res.ok) return null;
     const data = await res.json().catch(() => null);
-    if (!data?.project) return null;
-    return data.project.status ?? "draft";
+    const project = data?.project;
+    if (!project) return null;
+    return {
+      status: project.status ?? "draft",
+      coverUrl: project.thumbnailUrl ?? null,
+      coverSource: "coverSource" in project ? project.coverSource ?? null : void 0
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/lib/cover.ts
+import crypto4 from "crypto";
+import fs18 from "fs/promises";
+import path18 from "path";
+var COVER_MAX_BYTES = 8 * 1024 * 1024;
+var COVER_MIN_WIDTH = 320;
+var COVER_MIN_HEIGHT = 180;
+var SCRATCH_COVER_NAMES = ["cover.png", "cover.jpg", "cover.jpeg", "cover.webp"];
+var COVER_MEMO = ".genex/cover-upload.json";
+var STAND_IN_SOURCES = /* @__PURE__ */ new Set(["legacy", "ai", "inherited", "keyart", "session_shot"]);
+function coverIsStandIn(source) {
+  if (source === void 0) return false;
+  return source === null || STAND_IN_SOURCES.has(source);
+}
+var SOURCE_LABEL = {
+  owner: "chosen by the owner",
+  agent: "a frame set from the build (genex cover)",
+  owner_play: "captured while the owner played",
+  session_shot: "a screenshot from a build session (picked automatically)",
+  keyart: "the game's own menu art (picked automatically)",
+  inherited: "inherited from the game it was remixed from",
+  ai: "AI-generated",
+  legacy: "set before cover sources were recorded"
+};
+function describeCoverSource(source) {
+  if (source === void 0) return "not reported by this Genex stand";
+  if (source === null) return "none";
+  return SOURCE_LABEL[source] ?? source;
+}
+var COVER_ESCAPE = "If the game is dark by design and its frames come back refused, leave it: never change the game's lighting for a cover.";
+function coverNudge(source, hosted, last) {
+  if (!coverIsStandIn(source)) return null;
+  const state = source === null ? "This game has no cover yet" : "This game's cover is only a stand-in";
+  const frame = "real gameplay at its signature moment, well lit, no menus, popups or busy HUD, landscape 16:9, no text";
+  if (last === "rejected") {
+    const act = hosted ? "pass cover: true on the genex_browser check that shows it" : `save it over ${SCRATCH_DIR}/cover.png`;
+    return `\u279C ${state}, and the last frame sent was refused. Only if the game has a brighter moment (${frame}), ${act}; if it is dark by design, leave it \u2014 never change the game's lighting for a cover; the owner can set one on the game's page.`;
+  }
+  if (hosted) {
+    return `\u279C ${state}: once the game has a moment worth putting on its poster (${frame}), pass cover: true on the genex_browser check that shows it \u2014 that exact frame becomes the cover. ${COVER_ESCAPE}`;
+  }
+  return `\u279C ${state}: once the game has a moment worth putting on its poster, save that frame (${frame}) as ${SCRATCH_DIR}/cover.png \u2014 the next preview makes it the cover. ${COVER_ESCAPE}`;
+}
+function sniffImage(bytes) {
+  const b = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (b.length >= 24 && b.readUInt32BE(0) === 2303741511 && b.readUInt32BE(4) === 218765834) {
+    return { type: "image/png", width: b.readUInt32BE(16), height: b.readUInt32BE(20) };
+  }
+  if (b.length >= 3 && b[0] === 255 && b[1] === 216 && b[2] === 255) {
+    return { type: "image/jpeg", ...jpegSize(b) };
+  }
+  if (b.length >= 16 && b.toString("ascii", 0, 4) === "RIFF" && b.toString("ascii", 8, 12) === "WEBP") {
+    return { type: "image/webp", ...webpSize(b) };
+  }
+  return null;
+}
+function jpegSize(b) {
+  let i = 2;
+  while (i + 9 < b.length) {
+    if (b[i] !== 255) return { width: null, height: null };
+    const marker = b[i + 1];
+    if (marker === 255) {
+      i += 1;
+      continue;
+    }
+    if (marker === 1 || marker >= 208 && marker <= 216) {
+      i += 2;
+      continue;
+    }
+    if (marker === 218) break;
+    const isFrame = marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204;
+    if (isFrame) return { height: b.readUInt16BE(i + 5), width: b.readUInt16BE(i + 7) };
+    i += 2 + b.readUInt16BE(i + 2);
+  }
+  return { width: null, height: null };
+}
+function webpSize(b) {
+  const chunk = b.toString("ascii", 12, 16);
+  if (chunk === "VP8 " && b.length >= 30) {
+    return { width: b.readUInt16LE(26) & 16383, height: b.readUInt16LE(28) & 16383 };
+  }
+  if (chunk === "VP8L" && b.length >= 25) {
+    const bits = b.readUInt32LE(21);
+    return { width: (bits & 16383) + 1, height: (bits >>> 14 & 16383) + 1 };
+  }
+  if (chunk === "VP8X" && b.length >= 30) {
+    return { width: b.readUIntLE(24, 3) + 1, height: b.readUIntLE(27, 3) + 1 };
+  }
+  return { width: null, height: null };
+}
+function isFinalAnswer(outcome2) {
+  return outcome2.kind !== "failed";
+}
+function waitWords(retryAfter) {
+  const secs = Number(retryAfter);
+  if (!Number.isFinite(secs) || secs <= 0) return "later this hour (cover uploads are limited per hour)";
+  if (secs < 90) return `in about ${Math.ceil(secs)} seconds`;
+  const min = Math.ceil(secs / 60);
+  return `in about ${min} minute${min === 1 ? "" : "s"}`;
+}
+function refusal(res, what) {
+  const status2 = res.status;
+  if (status2 === 401) return "Genex refused this machine's sign-in \u2014 run `npx genex auth`, then try again.";
+  if (status2 === 403) return "Only the game's owner can set its cover, and this machine is signed in as someone else.";
+  if (status2 === 404) return "Genex doesn't know this game under this account \u2014 check `.genex/project.json` (or `npx genex link <slug>`).";
+  if (status2 === 413) return `That image is too big for a cover (at most ${COVER_MAX_BYTES / 1024 / 1024} MB).`;
+  if (status2 === 429) {
+    return `Too many cover uploads on this account for now \u2014 Genex takes the next one ${waitWords(res.headers.get("Retry-After"))}. Nothing to fix in the frame; the next preview sends it again by itself.`;
+  }
+  return `Couldn't ${what} (HTTP ${status2}) \u2014 try again.`;
+}
+var mb = (n) => `${(n / 1024 / 1024).toFixed(1)} MB`;
+async function uploadCover(args) {
+  const { apiUrl, token, projectId, bytes, label } = args;
+  const info = sniffImage(bytes);
+  if (!info) return { kind: "invalid", message: `${label} is not a PNG, JPEG or WebP image.` };
+  if (bytes.byteLength > COVER_MAX_BYTES) {
+    return {
+      kind: "invalid",
+      message: `${label} is ${mb(bytes.byteLength)}; a cover can be at most ${COVER_MAX_BYTES / 1024 / 1024} MB. Save the frame as a JPEG and try again.`
+    };
+  }
+  if (info.width !== null && info.height !== null && (info.width < COVER_MIN_WIDTH || info.height < COVER_MIN_HEIGHT)) {
+    return {
+      kind: "invalid",
+      message: `${label} is only ${info.width}\xD7${info.height}; a cover needs at least ${COVER_MIN_WIDTH}\xD7${COVER_MIN_HEIGHT}. Capture the game at its normal window size.`
+    };
+  }
+  const headers = { "Content-Type": "application/json", Authorization: `Bearer ${token}` };
+  const base = `${apiUrl}/api/projects/${encodeURIComponent(projectId)}/cover`;
+  let minted;
+  try {
+    minted = await apiFetch(`${base}/upload-url`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ bytes: bytes.byteLength, contentType: info.type })
+    });
+  } catch {
+    return { kind: "failed", message: "Couldn't reach Genex to upload the cover." };
+  }
+  if (printedStructuredError(minted)) return { kind: "failed", message: null };
+  if (!minted.ok) return { kind: "failed", message: refusal(minted, "start the cover upload") };
+  const grant = await minted.json().catch(() => null);
+  if (!grant?.uploadUrl) return { kind: "failed", message: "Genex answered the cover upload unexpectedly \u2014 nothing was uploaded." };
+  if (!grant.key) {
+    return { kind: "failed", message: "This Genex stand doesn't take covers from the CLI yet \u2014 nothing was uploaded." };
+  }
+  let put;
+  try {
+    put = await fetch(grant.uploadUrl, {
+      method: "PUT",
+      // Both are part of what the URL was signed for; send them back unchanged.
+      headers: { "Content-Type": info.type, "Content-Length": String(bytes.byteLength) },
+      body: new Uint8Array(bytes)
+    });
+  } catch {
+    return { kind: "failed", message: "The cover upload didn't reach storage (network error) \u2014 try again." };
+  }
+  if (!put.ok) return { kind: "failed", message: `The cover upload failed (HTTP ${put.status}) \u2014 try again.` };
+  let done;
+  try {
+    done = await apiFetch(`${base}/commit`, { method: "POST", headers, body: JSON.stringify({ key: grant.key }) });
+  } catch {
+    return { kind: "failed", message: "Couldn't reach Genex to finish the cover upload." };
+  }
+  if (printedStructuredError(done)) return { kind: "failed", message: null };
+  const body = await done.json().catch(() => null);
+  if (done.status === 422 && body?.error === "cover_rejected") {
+    return { kind: "rejected", reason: body.reason ?? "rejected", stats: body.stats ?? null };
+  }
+  if (!done.ok) return { kind: "failed", message: refusal(done, "set the cover") };
+  const view = { coverUrl: body?.coverUrl ?? null, coverSource: body?.coverSource ?? null };
+  return body?.applied === false ? { kind: "outranked", ...view } : { kind: "applied", ...view };
+}
+var pct = (n) => `${Math.round(n * 100)}%`;
+function reportCoverOutcome(log, outcome2, opts) {
+  const fail5 = (m) => opts.asError ? log.error(m) : log.warn(m);
+  switch (outcome2.kind) {
+    case "applied":
+      log.success(`Cover set \u2014 ${opts.label} is this game's cover now.`);
+      if (opts.showUrl && outcome2.coverUrl) log.dim(`  ${outcome2.coverUrl}`);
+      return;
+    case "outranked":
+      log.info("Cover unchanged \u2014 the owner picked this game's cover themselves, and that choice stands. Nothing to retry (the owner changes it on the game's page).");
+      return;
+    case "rejected": {
+      const why = outcome2.reason === "too_dark" ? "is too dark to read as the game on a gallery card" : outcome2.reason === "flat" ? "is almost one flat colour \u2014 a loading screen, a fade or an empty sky reads as nothing on a card" : `was refused (${outcome2.reason})`;
+      fail5(`Cover not used \u2014 ${opts.label} ${why}.`);
+      if (outcome2.stats) {
+        const s = outcome2.stats;
+        log.dim(`  brightness ${pct(s.mean)} \xB7 contrast ${pct(s.std)} \xB7 ${pct(s.darkShare)} near-black`);
+      }
+      log.dim(`  ${opts.retry}`);
+      return;
+    }
+    case "invalid":
+      fail5(`Cover not used \u2014 ${outcome2.message}`);
+      return;
+    case "failed":
+      if (outcome2.message) fail5(outcome2.message);
+      return;
+  }
+}
+function sha256(bytes) {
+  return crypto4.createHash("sha256").update(bytes).digest("hex");
+}
+async function readCoverMemo(cwd = process.cwd()) {
+  try {
+    const memo = JSON.parse(await fs18.readFile(path18.join(cwd, COVER_MEMO), "utf8"));
+    return typeof memo.sha256 === "string" ? memo : null;
+  } catch {
+    return null;
+  }
+}
+async function rememberCoverUpload(bytes, file, outcome2, cwd = process.cwd()) {
+  if (!isFinalAnswer(outcome2)) return;
+  const memo = { sha256: sha256(bytes), file, outcome: outcome2.kind, at: (/* @__PURE__ */ new Date()).toISOString() };
+  try {
+    await fs18.mkdir(path18.join(cwd, ".genex"), { recursive: true });
+    await fs18.writeFile(path18.join(cwd, COVER_MEMO), JSON.stringify(memo, null, 2) + "\n");
+  } catch {
+  }
+}
+async function findScratchCover(cwd = process.cwd()) {
+  let best = null;
+  for (const name of SCRATCH_COVER_NAMES) {
+    const rel = `${SCRATCH_DIR}/${name}`;
+    try {
+      const stat = await fs18.stat(path18.join(cwd, rel));
+      if (stat.isFile() && (!best || stat.mtimeMs > best.mtime)) best = { rel, mtime: stat.mtimeMs };
+    } catch {
+    }
+  }
+  return best?.rel ?? null;
+}
+async function pickUpScratchCover(args) {
+  const cwd = args.cwd ?? process.cwd();
+  try {
+    const rel = await findScratchCover(cwd);
+    if (!rel) return null;
+    const bytes = await fs18.readFile(path18.join(cwd, rel));
+    const memo = await readCoverMemo(cwd);
+    if (memo?.sha256 === sha256(bytes)) return null;
+    const outcome2 = await uploadCover({ apiUrl: args.apiUrl, token: args.token, projectId: args.projectId, bytes, label: rel });
+    reportCoverOutcome(args.log, outcome2, {
+      label: rel,
+      retry: "Save a better frame over it and the next preview tries again \u2014 or, if the game is dark by design, leave it: never change the game's lighting for a cover."
+    });
+    await rememberCoverUpload(bytes, rel, outcome2, cwd);
+    return outcome2;
   } catch {
     return null;
   }
@@ -5824,9 +6087,10 @@ async function runPreview(opts) {
     process.exitCode = 1;
     return;
   }
-  const freshStatus = await fetchProjectStatus(apiUrl, token, meta.slug);
-  if (freshStatus && freshStatus !== meta.status) {
-    meta.status = freshStatus;
+  await pickUpScratchCover({ apiUrl, token, projectId: meta.id, log });
+  const fresh = await fetchOwnerProject(apiUrl, token, meta.slug);
+  if (fresh && fresh.status !== meta.status) {
+    meta.status = fresh.status;
   }
   const onDisk = await readProject();
   const merged = { ...onDisk ?? meta, status: meta.status, lastDeployAt: (/* @__PURE__ */ new Date()).toISOString() };
@@ -5845,6 +6109,12 @@ async function runPreview(opts) {
   if (dashboard) {
     log.plain(`  your game's page (share this link): ${c.cyan(draftPageUrl(dashboard, meta.slug))}`);
   }
+  const hosted = inHostedSession();
+  const nudge = hosted && !hostedBrowserCovers() ? null : coverNudge(fresh?.coverSource, hosted, (await readCoverMemo())?.outcome ?? null);
+  if (nudge) {
+    log.plain("");
+    log.plain(nudge);
+  }
 }
 
 // src/commands/remix.ts
@@ -5876,28 +6146,28 @@ function loggerFor(opts) {
 }
 async function readState(directory) {
   try {
-    const marker = path18.join(directory, ".genex", "remix-operation.json");
-    if ((await fs18.lstat(marker)).isSymbolicLink()) return null;
-    const value = JSON.parse(await fs18.readFile(marker, "utf8"));
+    const marker = path19.join(directory, ".genex", "remix-operation.json");
+    if ((await fs19.lstat(marker)).isSymbolicLink()) return null;
+    const value = JSON.parse(await fs19.readFile(marker, "utf8"));
     return value.schema === 1 && value.directory === directory && typeof value.operationId === "string" && /^[a-zA-Z0-9_-]{8,128}$/.test(value.operationId) && value.source && /^[a-f0-9]{40}$/.test(value.source.sourceCommitSha) ? value : null;
   } catch {
     return null;
   }
 }
 async function saveState(state) {
-  const dir = path18.join(state.directory, ".genex");
-  await fs18.mkdir(dir, { recursive: true, mode: 448 });
-  const temp = path18.join(dir, "remix-operation.next.json");
-  await fs18.writeFile(temp, JSON.stringify(state, null, 2) + "\n", { mode: 384 });
-  await fs18.rename(temp, path18.join(dir, "remix-operation.json"));
+  const dir = path19.join(state.directory, ".genex");
+  await fs19.mkdir(dir, { recursive: true, mode: 448 });
+  const temp = path19.join(dir, "remix-operation.next.json");
+  await fs19.writeFile(temp, JSON.stringify(state, null, 2) + "\n", { mode: 384 });
+  await fs19.rename(temp, path19.join(dir, "remix-operation.json"));
 }
 async function checkDestination(directory) {
   try {
-    const stat = await fs18.lstat(directory);
+    const stat = await fs19.lstat(directory);
     if (!stat.isDirectory() || stat.isSymbolicLink()) throw new RemixError("destination_occupied", "The destination is not a fresh directory. Choose a new folder.");
-    const entries = await fs18.readdir(directory);
+    const entries = await fs19.readdir(directory);
     if (!entries.length) return null;
-    const genex = await fs18.lstat(path18.join(directory, ".genex")).catch(() => null);
+    const genex = await fs19.lstat(path19.join(directory, ".genex")).catch(() => null);
     const state = genex?.isDirectory() && !genex.isSymbolicLink() ? await readState(directory) : null;
     if (state) return state;
     throw new RemixError("destination_occupied", "The destination already contains files. Choose a fresh folder; remix never clears an existing project.");
@@ -5908,7 +6178,7 @@ async function checkDestination(directory) {
 }
 async function assertReferenceParents(cwd) {
   for (const rel of [".genex", ".genex/refs"]) {
-    const stat = await fs18.lstat(path18.join(cwd, rel)).catch((err) => {
+    const stat = await fs19.lstat(path19.join(cwd, rel)).catch((err) => {
       if (err.code === "ENOENT") return null;
       throw err;
     });
@@ -5916,41 +6186,41 @@ async function assertReferenceParents(cwd) {
   }
 }
 async function archiveSourceInstructions(directory) {
-  const archive = path18.join(directory, ".genex", "source-instructions");
+  const archive = path19.join(directory, ".genex", "source-instructions");
   const rootArtifacts = /* @__PURE__ */ new Set([".claude", ".codex", ".cursor", ".agents", ".mcp.json", ".cursorrules", "DESIGN.md"]);
   const instructionNames = /* @__PURE__ */ new Set(["AGENTS.md", "CLAUDE.md", "GEMINI.md"]);
   const visit = async (dir) => {
-    for (const entry of await fs18.readdir(dir, { withFileTypes: true })) {
+    for (const entry of await fs19.readdir(dir, { withFileTypes: true })) {
       if (entry.name === ".genex" || entry.name === ".git" || entry.name === "node_modules") continue;
-      const from = path18.join(dir, entry.name), rel = path18.relative(directory, from);
+      const from = path19.join(dir, entry.name), rel = path19.relative(directory, from);
       if (instructionNames.has(entry.name) || dir === directory && rootArtifacts.has(entry.name)) {
-        const to = path18.join(archive, rel);
-        await fs18.mkdir(path18.dirname(to), { recursive: true });
-        if (await fs18.lstat(to).catch(() => null)) throw new RemixError("destination_changed", `Source instructions at ${rel} changed during preparation; both copies were retained.`);
-        await fs18.rename(from, to);
+        const to = path19.join(archive, rel);
+        await fs19.mkdir(path19.dirname(to), { recursive: true });
+        if (await fs19.lstat(to).catch(() => null)) throw new RemixError("destination_changed", `Source instructions at ${rel} changed during preparation; both copies were retained.`);
+        await fs19.rename(from, to);
       } else if (entry.isDirectory()) await visit(from);
     }
   };
   await visit(directory);
 }
 async function acquireLock(directory) {
-  const lock = path18.join(directory, ".genex", "remix.lock");
+  const lock = path19.join(directory, ".genex", "remix.lock");
   for (let attempt = 0; attempt < 2; attempt++) {
     try {
-      const handle = await fs18.open(lock, "wx", 384);
+      const handle = await fs19.open(lock, "wx", 384);
       await handle.writeFile(String(process.pid));
       await handle.close();
-      return () => fs18.unlink(lock).catch(() => {
+      return () => fs19.unlink(lock).catch(() => {
       });
     } catch (err) {
       if (err.code !== "EEXIST") throw err;
-      const pid = Number(await fs18.readFile(lock, "utf8").catch(() => ""));
+      const pid = Number(await fs19.readFile(lock, "utf8").catch(() => ""));
       if (!Number.isInteger(pid) || pid <= 0) throw new RemixError("remix_in_progress", "Another remix owns this destination. Retry after it finishes.");
       try {
         process.kill(pid, 0);
       } catch (probe) {
         if (probe.code === "ESRCH") {
-          await fs18.unlink(lock);
+          await fs19.unlink(lock);
           continue;
         }
       }
@@ -6036,13 +6306,13 @@ function pinRemixDependencies(pkg, version) {
   return warnings;
 }
 async function installRemixDependencies(cwd, pm, version, log, runner = childRun) {
-  const pkgPath = path18.join(cwd, "package.json");
-  const pkg = JSON.parse(await fs18.readFile(pkgPath, "utf8"));
+  const pkgPath = path19.join(cwd, "package.json");
+  const pkg = JSON.parse(await fs19.readFile(pkgPath, "utf8"));
   const warnings = pinRemixDependencies(pkg, version);
-  await fs18.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+  await fs19.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
   log.step(`Restoring dependencies with ${pm}; pinning ${CLI_PACKAGE}@${version} (${CLI_CHANNEL}).`);
   const args = pm === "npm" ? ["install", "--workspaces=false", "--no-audit", "--no-fund"] : pm === "pnpm" ? ["install", "--ignore-workspace", "--no-frozen-lockfile"] : ["install"];
-  if (pm === "yarn") await fs18.writeFile(path18.join(cwd, "yarn.lock"), "", { flag: "wx" }).catch((err) => {
+  if (pm === "yarn") await fs19.writeFile(path19.join(cwd, "yarn.lock"), "", { flag: "wx" }).catch((err) => {
     if (err.code !== "EEXIST") throw err;
   });
   await runner(cwd, pm, args);
@@ -6076,27 +6346,27 @@ function rebindRemixConfig(content, slug) {
 async function configureIdentity(state, log) {
   const cwd = state.directory, meta = state.project;
   await writeProject(meta, cwd);
-  const configFile = path18.join(cwd, "src", "genex.config.ts");
-  const config = await fs18.readFile(configFile, "utf8").catch((err) => {
+  const configFile = path19.join(cwd, "src", "genex.config.ts");
+  const config = await fs19.readFile(configFile, "utf8").catch((err) => {
     if (err.code === "ENOENT") return null;
     throw err;
   });
-  if (config !== null) await fs18.writeFile(configFile, rebindRemixConfig(config, meta.slug));
+  if (config !== null) await fs19.writeFile(configFile, rebindRemixConfig(config, meta.slug));
   await writeGameConfigFiles(meta, log, cwd);
   await writeGitignore(cwd, log);
   await installRemixProfile(cwd, state.apiUrl, log);
-  const manifestFile = path18.join(cwd, "package.json");
-  const manifest = JSON.parse(await fs18.readFile(manifestFile, "utf8"));
+  const manifestFile = path19.join(cwd, "package.json");
+  const manifest = JSON.parse(await fs19.readFile(manifestFile, "utf8"));
   manifest.genex.remixSource = { projectId: state.source.projectId, slug: state.source.slug, sourceCommitSha: state.source.sourceCommitSha, version: state.source.version, versionCertainty: state.source.versionCertainty };
-  await fs18.writeFile(manifestFile, JSON.stringify(manifest, null, 2) + "\n");
+  await fs19.writeFile(manifestFile, JSON.stringify(manifest, null, 2) + "\n");
   const possible = [];
   const quoted = new RegExp(`(["'\`])(?:${state.source.slug.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}|${state.source.projectId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")})\\1`);
   const scan = async (dir) => {
-    for (const entry of await fs18.readdir(dir, { withFileTypes: true })) {
+    for (const entry of await fs19.readdir(dir, { withFileTypes: true })) {
       if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-      const file = path18.join(dir, entry.name);
+      const file = path19.join(dir, entry.name);
       if (entry.isDirectory()) await scan(file);
-      else if (entry.isFile() && /\.(?:[cm]?[jt]sx?|html)$/.test(entry.name) && (await fs18.stat(file)).size < 1024 * 1024 && quoted.test(await fs18.readFile(file, "utf8"))) possible.push(path18.relative(cwd, file));
+      else if (entry.isFile() && /\.(?:[cm]?[jt]sx?|html)$/.test(entry.name) && (await fs19.stat(file)).size < 1024 * 1024 && quoted.test(await fs19.readFile(file, "utf8"))) possible.push(path19.relative(cwd, file));
     }
   };
   await scan(cwd);
@@ -6121,7 +6391,7 @@ async function runRemix(opts, deps = {}) {
     const apiUrl = getApiUrl(opts.apiUrl), dashboardUrl = new URL(getAuthUrl(opts.authUrl)).origin;
     if (opts.sourceOnly && !opts.destination) await assertReferenceParents(originalCwd);
     const selected = parseRemixSource(opts.remixSource, apiUrl, dashboardUrl);
-    let directory = opts.destination ? path18.resolve(originalCwd, opts.destination) : !opts.sourceOnly ? path18.resolve(originalCwd, `${selected.slug}-remix`) : void 0;
+    let directory = opts.destination ? path19.resolve(originalCwd, opts.destination) : !opts.sourceOnly ? path19.resolve(originalCwd, `${selected.slug}-remix`) : void 0;
     if (directory) state = await checkDestination(directory);
     resumed = state !== null;
     if (state && (state.apiUrl !== apiUrl || state.sourceOnly !== Boolean(opts.sourceOnly) || ![state.requestedSlug, state.source.slug].includes(selected.slug) || opts.operationId && state.operationId !== opts.operationId || opts.name && state.name !== opts.name || selected.version && selected.version !== state.source.version)) throw new RemixError("operation_mismatch", "This folder belongs to a different remix operation. Resume with its original source/options or choose a fresh folder.");
@@ -6139,29 +6409,29 @@ async function runRemix(opts, deps = {}) {
       log.step(`Resolving source for ${selected.slug}\u2026`);
       const body = await responseJson(await request(`${apiUrl}/api/projects/${encodeURIComponent(selected.slug)}/source?${query}`, { headers, redirect: "error" }));
       validateSource(body, Boolean(opts.sourceOnly));
-      directory ??= path18.resolve(originalCwd, ".genex", "refs", `${body.source.slug}-${body.source.sourceCommitSha.slice(0, 12)}`);
+      directory ??= path19.resolve(originalCwd, ".genex", "refs", `${body.source.slug}-${body.source.sourceCommitSha.slice(0, 12)}`);
       const existing = await checkDestination(directory);
       if (existing) {
         if (!existing.sourceOnly || !opts.sourceOnly || existing.apiUrl !== apiUrl || existing.source.sourceCommitSha !== body.source.sourceCommitSha || existing.source.projectId !== body.source.projectId) throw new RemixError("destination_occupied", "This reference destination already belongs to another operation. Choose a fresh folder.");
         state = existing;
         resumed = true;
       } else {
-        state = { schema: 1, operationId: opts.operationId ?? crypto4.randomUUID(), directory, apiUrl, dashboardUrl, requestedSlug: selected.slug, source: body.source, sourceToken: body.sourceToken, sourceOnly: Boolean(opts.sourceOnly), cliVersion: getCliVersion(), name: opts.name?.trim() || `${body.source.title.slice(0, 74)} remix`, stage: "download", warnings: [...body.source.warnings] };
-        await fs18.mkdir(directory, { recursive: true });
-        if ((await fs18.readdir(directory)).length) throw new RemixError("destination_occupied", "The destination changed during setup. Choose a fresh folder.");
-        await fs18.mkdir(path18.join(directory, ".genex"), { mode: 448 });
+        state = { schema: 1, operationId: opts.operationId ?? crypto5.randomUUID(), directory, apiUrl, dashboardUrl, requestedSlug: selected.slug, source: body.source, sourceToken: body.sourceToken, sourceOnly: Boolean(opts.sourceOnly), cliVersion: getCliVersion(), name: opts.name?.trim() || `${body.source.title.slice(0, 74)} remix`, stage: "download", warnings: [...body.source.warnings] };
+        await fs19.mkdir(directory, { recursive: true });
+        if ((await fs19.readdir(directory)).length) throw new RemixError("destination_occupied", "The destination changed during setup. Choose a fresh folder.");
+        await fs19.mkdir(path19.join(directory, ".genex"), { mode: 448 });
         await saveState(state);
       }
     }
     unlock = await acquireLock(state.directory);
     state = await readState(state.directory) ?? state;
     if (resumed && state.stage === "download") await renewSource(state, request, headers);
-    const staging = path18.join(state.directory, ".genex", "remix-stage");
+    const staging = path19.join(state.directory, ".genex", "remix-stage");
     if (state.stage === "download") {
-      await fs18.rm(staging, { recursive: true, force: true });
-      await fs18.mkdir(staging, { recursive: true });
-      const archive = path18.join(staging, "source.zip"), sourceDir = path18.join(staging, "source");
-      await fs18.mkdir(sourceDir);
+      await fs19.rm(staging, { recursive: true, force: true });
+      await fs19.mkdir(staging, { recursive: true });
+      const archive = path19.join(staging, "source.zip"), sourceDir = path19.join(staging, "source");
+      await fs19.mkdir(sourceDir);
       const archiveUrl = new URL(state.source.archiveUrl, state.apiUrl);
       if (archiveUrl.origin !== new URL(state.apiUrl).origin || !archiveUrl.pathname.startsWith("/api/projects/")) throw new RemixError("invalid_source_response", "Source archive must be served by the selected Genex API.");
       log.step(`Downloading ${state.source.slug} at ${state.source.sourceCommitSha.slice(0, 12)}\u2026`);
@@ -6176,26 +6446,26 @@ async function runRemix(opts, deps = {}) {
       if (!state.sourceOnly) {
         let pkg;
         try {
-          pkg = JSON.parse(await fs18.readFile(path18.join(sourceDir, "package.json"), "utf8"));
+          pkg = JSON.parse(await fs19.readFile(path19.join(sourceDir, "package.json"), "utf8"));
         } catch (error) {
-          const staticEntry = await fs18.stat(path18.join(sourceDir, "index.html")).catch(() => null);
+          const staticEntry = await fs19.stat(path19.join(sourceDir, "index.html")).catch(() => null);
           if (error.code !== "ENOENT" || !staticEntry?.isFile()) throw new RemixError("source_unavailable", "Source has neither a readable package.json nor a static index.html. Use --source-only to inspect it.");
           pkg = { name: manifestName(state.directory), private: true };
-          await fs18.writeFile(path18.join(sourceDir, "package.json"), JSON.stringify(pkg, null, 2) + "\n");
+          await fs19.writeFile(path19.join(sourceDir, "package.json"), JSON.stringify(pkg, null, 2) + "\n");
           state.warnings.push("This static game had no package.json; added a minimal private manifest for the local CLI. Its source and index.html remain unchanged.");
         }
         if (!pkg || typeof pkg !== "object" || Array.isArray(pkg)) throw new RemixError("source_unavailable", "Source package.json is not a project manifest.");
       }
-      state.transferEntries = await fs18.readdir(sourceDir);
+      state.transferEntries = await fs19.readdir(sourceDir);
       state.stage = "transfer";
       await saveState(state);
     }
     if (state.stage === "transfer") {
       for (const entry of state.transferEntries ?? []) {
-        const from = path18.join(staging, "source", entry), to = path18.join(state.directory, entry);
-        if (await fs18.lstat(from).catch(() => null)) {
-          if (await fs18.lstat(to).catch(() => null)) throw new RemixError("destination_changed", `A file appeared at ${entry} during source preparation. It was left untouched.`);
-          await fs18.rename(from, to);
+        const from = path19.join(staging, "source", entry), to = path19.join(state.directory, entry);
+        if (await fs19.lstat(from).catch(() => null)) {
+          if (await fs19.lstat(to).catch(() => null)) throw new RemixError("destination_changed", `A file appeared at ${entry} during source preparation. It was left untouched.`);
+          await fs19.rename(from, to);
         }
       }
       if (!state.sourceOnly) {
@@ -6204,7 +6474,7 @@ async function runRemix(opts, deps = {}) {
       }
       state.stage = state.sourceOnly ? "prepared" : "configure";
       await saveState(state);
-      await fs18.rm(staging, { recursive: true, force: true });
+      await fs19.rm(staging, { recursive: true, force: true });
     }
     process.chdir(state.directory);
     if (state.stage === "configure") {
@@ -6275,8 +6545,8 @@ async function runRemix(opts, deps = {}) {
 }
 
 // src/commands/init.ts
-import fs19 from "fs/promises";
-import path19 from "path";
+import fs20 from "fs/promises";
+import path20 from "path";
 
 // src/lib/printed.ts
 var printed = /* @__PURE__ */ new WeakSet();
@@ -6317,7 +6587,7 @@ var TOOLING_ENTRIES = /* @__PURE__ */ new Set([
 ]);
 async function listPreexistingEntries(dir) {
   try {
-    return (await fs19.readdir(dir)).filter((name) => !TOOLING_ENTRIES.has(name)).sort();
+    return (await fs20.readdir(dir)).filter((name) => !TOOLING_ENTRIES.has(name)).sort();
   } catch {
     return [];
   }
@@ -6384,8 +6654,8 @@ async function runInit(opts) {
   let totalNew = 0;
   let totalUpdated = 0;
   for (const t of targets) {
-    const src = t.full ? templatesDir : path19.join(templatesDir, "skills");
-    const dest = t.full ? t.baseDir : path19.join(t.baseDir, "skills");
+    const src = t.full ? templatesDir : path20.join(templatesDir, "skills");
+    const dest = t.full ? t.baseDir : path20.join(t.baseDir, "skills");
     const family = remixing ? skillFamilyFilter("remix") : converting ? skillFamilyFilter("tools", { hosted: true }) : skillFamilyFilter("game");
     if (remixing) await pruneRemixWorkflow(t.baseDir);
     const { copied, updated } = await copyTemplates(src, dest, {
@@ -6393,8 +6663,8 @@ async function runInit(opts) {
       exclude: ["controllers", "motion", "asset-viewer", "blender-service"],
       filter: t.full ? family : (rel) => family(`skills/${rel}`)
     });
-    await pruneRemovedSkills(path19.join(t.baseDir, "skills"), log);
-    await writeSkillsMarker(path19.join(t.baseDir, "skills"));
+    await pruneRemovedSkills(path20.join(t.baseDir, "skills"), log);
+    await writeSkillsMarker(path20.join(t.baseDir, "skills"));
     const added = copied.length - updated.length;
     totalNew += added;
     totalUpdated += updated.length;
@@ -6452,7 +6722,7 @@ async function runInit(opts) {
     if (email) log.plain(`  signed in as ${c.cyan(email)}`);
   };
   await echoIdentity();
-  const projectName = opts.name?.trim() || path19.basename(process.cwd());
+  const projectName = opts.name?.trim() || path20.basename(process.cwd());
   const create = (bearer) => createDraftProject({
     apiUrl,
     token: bearer,
@@ -6504,7 +6774,7 @@ async function runInit(opts) {
     if (await writeToolsContract(process.cwd(), { hosted: true })) {
       log.dim("  wrote the Genex Tools publishing rules into AGENTS.md (managed block)");
     }
-    await ensureEnvVar(path19.join(process.cwd(), ".env"), "VITE_GENEX_SLUG", meta.slug, log);
+    await ensureEnvVar(path20.join(process.cwd(), ".env"), "VITE_GENEX_SLUG", meta.slug, log);
     await reportCliEvent(apiUrl, token, "tools_converted");
   }
   if (!remixing) warnPreexisting(log, preexisting);
@@ -6531,9 +6801,9 @@ async function runInit(opts) {
 }
 
 // src/commands/link.ts
-import fs20 from "fs/promises";
+import fs21 from "fs/promises";
 import os6 from "os";
-import path20 from "path";
+import path21 from "path";
 async function runLink(opts) {
   const log = createLogger({ quiet: opts.quiet });
   log.plain(c.bold("genex link"));
@@ -6615,7 +6885,7 @@ async function runLink(opts) {
 }
 async function isEmptyDir(cwd) {
   try {
-    const entries = await fs20.readdir(cwd);
+    const entries = await fs21.readdir(cwd);
     return entries.every((e) => e === ".git" || e === ".genex" || e === ".DS_Store");
   } catch {
     return false;
@@ -6629,13 +6899,13 @@ async function downloadSource(apiUrl, token, project, log) {
     return false;
   }
   log.step(`Downloading the ${grant.sourceRef === "preview" ? "draft" : "published"} source\u2026`);
-  const staging = await fs20.mkdtemp(path20.join(os6.tmpdir(), "genex-link-"));
-  const fresh = path20.join(staging, "source");
+  const staging = await fs21.mkdtemp(path21.join(os6.tmpdir(), "genex-link-"));
+  const fresh = path21.join(staging, "source");
   try {
     if (!await cloneSource(grant, fresh, log)) return false;
-    await fs20.rm(path20.join(fresh, ".git"), { recursive: true, force: true });
-    for (const entry of await fs20.readdir(fresh)) {
-      await fs20.cp(path20.join(fresh, entry), path20.join(process.cwd(), entry), {
+    await fs21.rm(path21.join(fresh, ".git"), { recursive: true, force: true });
+    for (const entry of await fs21.readdir(fresh)) {
+      await fs21.cp(path21.join(fresh, entry), path21.join(process.cwd(), entry), {
         recursive: true,
         force: true
       });
@@ -6643,28 +6913,28 @@ async function downloadSource(apiUrl, token, project, log) {
     log.success("Downloaded.");
     return true;
   } finally {
-    await fs20.rm(staging, { recursive: true, force: true }).catch(() => {
+    await fs21.rm(staging, { recursive: true, force: true }).catch(() => {
     });
   }
 }
 async function ensureSlugEnv(slug, log, cwd = process.cwd()) {
-  const file = path20.join(cwd, ".env");
+  const file = path21.join(cwd, ".env");
   let content;
   try {
-    content = await fs20.readFile(file, "utf8");
+    content = await fs21.readFile(file, "utf8");
   } catch {
     return;
   }
   const re = /^(\s*VITE_GENEX_SLUG=)(.*)$/m;
   const m = content.match(re);
   if (!m) {
-    await fs20.appendFile(file, `${content.endsWith("\n") ? "" : "\n"}VITE_GENEX_SLUG=${slug}
+    await fs21.appendFile(file, `${content.endsWith("\n") ? "" : "\n"}VITE_GENEX_SLUG=${slug}
 `);
     log.dim(`  added VITE_GENEX_SLUG=${slug} to .env`);
     return;
   }
   if (m[2].trim() === slug) return;
-  await fs20.writeFile(file, content.replace(re, `$1${slug}`));
+  await fs21.writeFile(file, content.replace(re, `$1${slug}`));
   log.dim(`  updated .env: VITE_GENEX_SLUG=${slug} (was ${m[2].trim()})`);
 }
 async function fetchOwnProject(apiUrl, token, slug, log) {
@@ -6718,8 +6988,8 @@ async function listOwnSlugs(apiUrl, token, log) {
 }
 
 // src/commands/pull.ts
-import fs21 from "fs/promises";
-import path21 from "path";
+import fs22 from "fs/promises";
+import path22 from "path";
 import os7 from "os";
 function isMachineLocal(entry) {
   if (entry === ".genex" || entry === "node_modules" || entry === ".git") return true;
@@ -6779,23 +7049,23 @@ async function runPull(opts) {
     process.exitCode = 1;
     return;
   }
-  const staging = await fs21.mkdtemp(path21.join(os7.tmpdir(), "genex-pull-"));
-  const fresh = path21.join(staging, "source");
+  const staging = await fs22.mkdtemp(path22.join(os7.tmpdir(), "genex-pull-"));
+  const fresh = path22.join(staging, "source");
   try {
     if (!await cloneSource(grant, fresh, log)) {
       process.exitCode = 1;
       return;
     }
-    await fs21.rm(path21.join(fresh, ".git"), { recursive: true, force: true });
+    await fs22.rm(path22.join(fresh, ".git"), { recursive: true, force: true });
     const kept = await keepReplaced(cwd, log);
     await replaceTree(cwd, fresh);
     if (kept) {
       log.plain("");
-      log.info(`What was here is kept at ${c.cyan(path21.relative(cwd, kept) || kept)}`);
+      log.info(`What was here is kept at ${c.cyan(path22.relative(cwd, kept) || kept)}`);
       log.dim("  Nothing was thrown away \u2014 re-apply from there, or delete it when you are done.");
     }
   } finally {
-    await fs21.rm(staging, { recursive: true, force: true }).catch(() => {
+    await fs22.rm(staging, { recursive: true, force: true }).catch(() => {
     });
   }
   if (await hasRemixProfile(cwd)) await installRemixProfile(cwd, apiUrl, log);
@@ -6815,13 +7085,13 @@ async function runPull(opts) {
 }
 async function keepReplaced(cwd, log) {
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const dest = path21.join(cwd, ".genex", `replaced-${stamp}`);
+  const dest = path22.join(cwd, ".genex", `replaced-${stamp}`);
   try {
-    const entries = (await fs21.readdir(cwd)).filter((e) => !isMachineLocal(e));
+    const entries = (await fs22.readdir(cwd)).filter((e) => !isMachineLocal(e));
     if (entries.length === 0) return null;
-    await fs21.mkdir(dest, { recursive: true });
+    await fs22.mkdir(dest, { recursive: true });
     for (const entry of entries) {
-      await fs21.cp(path21.join(cwd, entry), path21.join(dest, entry), { recursive: true });
+      await fs22.cp(path22.join(cwd, entry), path22.join(dest, entry), { recursive: true });
     }
     return dest;
   } catch (err) {
@@ -6831,19 +7101,19 @@ async function keepReplaced(cwd, log) {
   }
 }
 async function replaceTree(dest, src) {
-  for (const entry of await fs21.readdir(dest)) {
+  for (const entry of await fs22.readdir(dest)) {
     if (isMachineLocal(entry)) continue;
-    await fs21.rm(path21.join(dest, entry), { recursive: true, force: true });
+    await fs22.rm(path22.join(dest, entry), { recursive: true, force: true });
   }
-  for (const entry of await fs21.readdir(src)) {
+  for (const entry of await fs22.readdir(src)) {
     if (isMachineLocal(entry)) continue;
-    await fs21.cp(path21.join(src, entry), path21.join(dest, entry), { recursive: true });
+    await fs22.cp(path22.join(src, entry), path22.join(dest, entry), { recursive: true });
   }
 }
 
 // src/commands/rename.ts
-import fs22 from "fs/promises";
-import path22 from "path";
+import fs23 from "fs/promises";
+import path23 from "path";
 async function runRename(opts) {
   const log = createLogger({ quiet: opts.quiet });
   log.plain(c.bold("genex rename"));
@@ -6931,23 +7201,23 @@ async function runRename(opts) {
   log.info("Run `genex preview` (or `publish`) to rebuild \u2014 the new slug is baked into the bundle.");
 }
 async function rewriteSlugEnv(from, to, log, cwd = process.cwd()) {
-  const file = path22.join(cwd, ".env");
+  const file = path23.join(cwd, ".env");
   let content;
   try {
-    content = await fs22.readFile(file, "utf8");
+    content = await fs23.readFile(file, "utf8");
   } catch {
     return;
   }
   const re = /^(\s*VITE_GENEX_SLUG=)(.*)$/m;
   if (!re.test(content)) return;
-  await fs22.writeFile(file, content.replace(re, `$1${to}`));
+  await fs23.writeFile(file, content.replace(re, `$1${to}`));
   log.dim(`  .env: VITE_GENEX_SLUG=${to} (was ${from})`);
 }
 async function rewriteBakedSlug(from, to, log, cwd = process.cwd()) {
-  const file = path22.join(cwd, "src", "genex.config.ts");
+  const file = path23.join(cwd, "src", "genex.config.ts");
   let content;
   try {
-    content = await fs22.readFile(file, "utf8");
+    content = await fs23.readFile(file, "utf8");
   } catch {
     return;
   }
@@ -6957,7 +7227,7 @@ async function rewriteBakedSlug(from, to, log, cwd = process.cwd()) {
     log.warn(`  src/genex.config.ts has no "${from}" literal \u2014 check its slug by hand.`);
     return;
   }
-  await fs22.writeFile(file, content.replace(quoted, `"${to}"`));
+  await fs23.writeFile(file, content.replace(quoted, `"${to}"`));
   log.dim(`  src/genex.config.ts: baked slug -> ${to}`);
 }
 
@@ -7365,7 +7635,7 @@ async function runShop(opts) {
   const auth = { Authorization: `Bearer ${token}`, "Content-Type": "application/json" };
   const call = (url, init2) => apiFetch(url, { ...init2, headers: { ...auth, ...init2?.headers ?? {} } });
   const projectSkus = `${apiUrl}/api/coin/projects/${encodeURIComponent(meta.id)}/skus`;
-  async function fail4(res2, what) {
+  async function fail5(res2, what) {
     if (printedStructuredError(res2)) {
       process.exitCode = 1;
       return;
@@ -7386,7 +7656,7 @@ async function runShop(opts) {
   }
   if (sub === "list") {
     const res2 = await call(projectSkus);
-    if (!res2.ok) return fail4(res2, "read your shop");
+    if (!res2.ok) return fail5(res2, "read your shop");
     const body = await res2.json();
     if (opts.json) {
       log.plain(JSON.stringify(body, null, 2));
@@ -7431,7 +7701,7 @@ async function runShop(opts) {
         ...opts.resellable !== void 0 ? { resellable: opts.resellable } : {}
       })
     });
-    if (!res2.ok) return fail4(res2, "add that item");
+    if (!res2.ok) return fail5(res2, "add that item");
     const sku = await res2.json();
     if (opts.json) {
       log.plain(JSON.stringify(sku, null, 2));
@@ -7452,7 +7722,7 @@ async function runShop(opts) {
   const skuUrl = `${apiUrl}/api/coin/skus/${encodeURIComponent(skuId)}`;
   if (sub === "test") {
     const res2 = await call(`${skuUrl}/test-grant`, { method: "POST" });
-    if (!res2.ok) return fail4(res2, "grant yourself a test copy");
+    if (!res2.ok) return fail5(res2, "grant yourself a test copy");
     const got = await res2.json();
     log.success(`You now own ${c.cyan(got.name)} in this game.`);
     log.dim("  It cost nothing and no sale was recorded \u2014 it is a test copy.");
@@ -7475,14 +7745,14 @@ async function runShop(opts) {
       return;
     }
     const res2 = await call(skuUrl, { method: "PATCH", body: JSON.stringify(patch) });
-    if (!res2.ok) return fail4(res2, "update that item");
+    if (!res2.ok) return fail5(res2, "update that item");
     const sku = await res2.json();
     log.success(`Updated ${c.cyan(sku.name)} \u2014 ${sku.priceCoins} coin.`);
     if (opts.resellable === false) log.dim("  Listings already on the market stay up.");
     return;
   }
   const res = await call(skuUrl, { method: "DELETE" });
-  if (!res.ok) return fail4(res, "remove that item");
+  if (!res.ok) return fail5(res, "remove that item");
   log.success("Removed from the shop.");
   log.dim("  Players who already bought it keep it.");
 }
@@ -7668,6 +7938,12 @@ async function runPublish(opts) {
     process.exitCode = 1;
     return;
   }
+  const listed = await res.json().catch(() => null);
+  if (opts.regenerateCover && listed?.project?.coverAiEnabled === false) {
+    log.dim("  --regenerate-cover did nothing: this stand doesn't make AI covers.");
+    log.dim("  The cover is a real frame of the game \u2014 set one with `npx genex cover <file>`.");
+  }
+  await pickUpScratchCover({ apiUrl, token, projectId: meta.id, log });
   log.plain("");
   log.success("Published. \u{1F389}");
   const dashboard = meta.dashboardOrigins?.[0];
@@ -7956,9 +8232,101 @@ async function runRollback(opts) {
   log.dim(`  To undo this and go forward again: ${c.cyan("npx genex rollback")}`);
 }
 
+// src/commands/cover.ts
+import fs24 from "fs/promises";
+import path24 from "path";
+var WHAT_A_COVER_IS = "one real frame of the game: its signature moment, real gameplay, well lit, no menus, popups or busy HUD, landscape 16:9, no text";
+async function runCover(opts) {
+  const log = createLogger({ quiet: opts.quiet || opts.json });
+  log.plain(c.bold("genex cover"));
+  log.plain("");
+  const meta = await readProject();
+  if (!meta) {
+    return fail2("No genex project here. Run `genex init` (or `genex link <slug>`) in this directory first.", opts, log);
+  }
+  const apiUrl = getApiUrl(opts.apiUrl ?? meta.apiUrl);
+  const token = await readUserToken(opts.envPath, apiUrl);
+  if (!token) return fail2("Not signed in. Run `genex auth` first.", opts, log);
+  const file = opts.imagePath?.trim();
+  if (!file) {
+    await showCover(apiUrl, token, meta.slug, opts, log);
+    return;
+  }
+  let bytes;
+  try {
+    const stat = await fs24.stat(file);
+    if (!stat.isFile()) throw new Error("not a file");
+    if (stat.size > COVER_MAX_BYTES) {
+      return finish(
+        { kind: "invalid", message: `${file} is ${(stat.size / 1024 / 1024).toFixed(1)} MB; a cover can be at most ${COVER_MAX_BYTES / 1024 / 1024} MB. Save the frame as a JPEG and try again.` },
+        file,
+        opts,
+        log
+      );
+    }
+    bytes = await fs24.readFile(file);
+  } catch {
+    return finish({ kind: "invalid", message: `Can't read ${file} \u2014 pass the path of a PNG, JPEG or WebP image.` }, file, opts, log);
+  }
+  log.step(`Uploading ${path24.basename(file)} as the cover\u2026`);
+  const outcome2 = await uploadCover({ apiUrl, token, projectId: meta.id, bytes, label: file });
+  await rememberNomination(bytes, file, outcome2);
+  finish(outcome2, file, opts, log);
+}
+async function rememberNomination(bytes, file, outcome2) {
+  const scratch = await findScratchCover();
+  if (!scratch || path24.resolve(scratch) === path24.resolve(file)) {
+    await rememberCoverUpload(bytes, file, outcome2);
+    return;
+  }
+  if (outcome2.kind !== "applied" && outcome2.kind !== "outranked") return;
+  const stale = await fs24.readFile(scratch).catch(() => null);
+  if (stale) await rememberCoverUpload(stale, scratch, outcome2);
+}
+function fail2(message, opts, log) {
+  if (opts.json) process.stdout.write(`${JSON.stringify({ file: opts.imagePath?.trim() || null, kind: "failed", message })}
+`);
+  else log.error(message);
+  process.exitCode = 1;
+}
+function finish(outcome2, file, opts, log) {
+  if (opts.json) {
+    process.stdout.write(`${JSON.stringify({ file, ...outcome2 })}
+`);
+  } else {
+    reportCoverOutcome(log, outcome2, {
+      label: file,
+      retry: "Capture a brighter moment of real gameplay and run this again \u2014 or, if the game is dark by design, stop here: never change the game's lighting for a cover.",
+      showUrl: true,
+      asError: true
+    });
+  }
+  if (outcome2.kind !== "applied" && outcome2.kind !== "outranked") process.exitCode = 1;
+}
+async function showCover(apiUrl, token, slug, opts, log) {
+  const view = await fetchOwnerProject(apiUrl, token, slug);
+  if (!view) return fail2("Couldn't read this game from Genex \u2014 check the sign-in (`genex doctor`) and try again.", opts, log);
+  if (opts.json) {
+    process.stdout.write(`${JSON.stringify({ coverUrl: view.coverUrl, coverSource: view.coverSource ?? null })}
+`);
+    return;
+  }
+  if (!view.coverUrl) {
+    log.plain("  This game has no cover yet.");
+  } else {
+    log.plain(`  cover:  ${c.cyan(view.coverUrl)}`);
+    log.plain(`  source: ${describeCoverSource(view.coverSource)}`);
+  }
+  if (!view.coverUrl || coverIsStandIn(view.coverSource)) {
+    log.plain("");
+    log.dim(`  A cover is ${WHAT_A_COVER_IS}.`);
+    log.dim(`  Save one as ${SCRATCH_DIR}/cover.png and run: npx genex cover ${SCRATCH_DIR}/cover.png`);
+  }
+}
+
 // src/commands/generate.ts
-import fs25 from "fs/promises";
-import path25 from "path";
+import fs27 from "fs/promises";
+import path27 from "path";
 import { PNG as PNG4 } from "pngjs";
 
 // src/lib/glass.ts
@@ -8140,13 +8508,13 @@ function ceilingVerdict(input) {
 }
 
 // src/lib/generation-admission.ts
-import fs24 from "fs/promises";
-import path24 from "path";
+import fs26 from "fs/promises";
+import path26 from "path";
 import { createHash, randomUUID } from "crypto";
 
 // src/lib/asset-budget.ts
-import fs23 from "fs/promises";
-import path23 from "path";
+import fs25 from "fs/promises";
+import path25 from "path";
 var DEFAULT_ASSET_BUDGET_SHARE = 0.5;
 var DEFAULT_ASSET_BUDGET_CAP = 500;
 function envShare(raw, fallback) {
@@ -8173,10 +8541,10 @@ function allowanceFor(input) {
   if (!Number.isFinite(spendable) || spendable <= 0) return 0;
   return Math.max(0, Math.min(Math.floor(spendable * config.share), config.cap));
 }
-var storePath = (cwd) => path23.join(cwd, ".genex", "asset-budget.json");
+var storePath = (cwd) => path25.join(cwd, ".genex", "asset-budget.json");
 async function readBudgetStore(cwd = process.cwd()) {
   try {
-    const raw = await fs23.readFile(storePath(cwd), "utf8");
+    const raw = await fs25.readFile(storePath(cwd), "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed || parsed.v !== 1 || typeof parsed.allowanceCredits !== "number" || !Number.isFinite(parsed.allowanceCredits) || parsed.setBy !== "default" && parsed.setBy !== "user") {
       return null;
@@ -8195,8 +8563,8 @@ async function readBudgetStore(cwd = process.cwd()) {
 }
 async function writeBudgetStore(cwd, store) {
   try {
-    await fs23.access(path23.join(cwd, ".genex"));
-    await fs23.writeFile(storePath(cwd), `${JSON.stringify(store, null, 2)}
+    await fs25.access(path25.join(cwd, ".genex"));
+    await fs25.writeFile(storePath(cwd), `${JSON.stringify(store, null, 2)}
 `, "utf8");
     return true;
   } catch {
@@ -8207,7 +8575,7 @@ async function ensureBudgetStore(cwd, input) {
   const existing = await readBudgetStore(cwd);
   if (existing) return existing;
   try {
-    await fs23.stat(storePath(cwd));
+    await fs25.stat(storePath(cwd));
     throw new Error("Stored asset allowance is unreadable or invalid; reconcile it before paid generation.");
   } catch (error) {
     if (error.code !== "ENOENT") throw error;
@@ -8311,12 +8679,12 @@ async function assetBudgetGate(input) {
 
 // src/lib/generation-admission.ts
 async function withAdmissionLock(cwd, work, waitMs = 3e4) {
-  const lock = path24.join(cwd, ".genex", "generation-admission.lock");
+  const lock = path26.join(cwd, ".genex", "generation-admission.lock");
   const deadline = Date.now() + waitMs;
   let file;
   while (!file) {
     try {
-      file = await fs24.open(lock, "wx");
+      file = await fs26.open(lock, "wx");
     } catch (error) {
       if (error.code !== "EEXIST") throw error;
       if (Date.now() >= deadline) throw new Error("Another generation admission holds .genex/generation-admission.lock. If its process died, reconcile pending reservations before removing that lock.");
@@ -8328,7 +8696,7 @@ async function withAdmissionLock(cwd, work, waitMs = 3e4) {
     return await work();
   } finally {
     await file.close();
-    await fs24.unlink(lock);
+    await fs26.unlink(lock);
   }
 }
 async function enqueueWithAllowance(input) {
@@ -8577,7 +8945,7 @@ var isRemoteRef = (value) => /^(https?:\/\/|data:)/i.test(value);
 async function inlineLocalImage(filePath, flag) {
   let bytes;
   try {
-    bytes = await fs25.readFile(filePath);
+    bytes = await fs27.readFile(filePath);
   } catch {
     return { ok: false, error: `Couldn't read the ${flag} file at ${filePath}.` };
   }
@@ -8587,7 +8955,7 @@ async function inlineLocalImage(filePath, flag) {
       error: `${flag} file is ${(bytes.length / 1048576).toFixed(1)} MB \u2014 over the ~4 MB inline limit. Downscale/compress it first, or pass an asset URL instead.`
     };
   }
-  const mime = IMAGE_MIME_BY_EXT[path25.extname(filePath).toLowerCase()] ?? "image/png";
+  const mime = IMAGE_MIME_BY_EXT[path27.extname(filePath).toLowerCase()] ?? "image/png";
   return { ok: true, dataUri: `data:${mime};base64,${bytes.toString("base64")}` };
 }
 var SKYBOX_ENVIRONMENT_SUFFIX = ". The image contains ONLY sky: cloud, atmosphere, light, weather and distant haze at the horizon. Every structure, object, plant and ground surface is outside the frame.";
@@ -8782,7 +9150,7 @@ async function runGenerate(kind, opts) {
   let typedPrompt = opts.prompt?.trim();
   if (!typedPrompt && kind === "model" && opts.imageUrl) {
     const ref = opts.imageUrl.startsWith("data:") ? "local image" : opts.imageUrl;
-    typedPrompt = `from image: ${path25.basename(ref).slice(0, 120)}`;
+    typedPrompt = `from image: ${path27.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).`);
@@ -8831,7 +9199,7 @@ async function runGenerate(kind, opts) {
       return;
     }
     try {
-      const bytes = await fs25.readFile(opts.inpaintUrl);
+      const bytes = await fs27.readFile(opts.inpaintUrl);
       opts = { ...opts, inpaintUrl: `data:image/png;base64,${bytes.toString("base64")}` };
     } catch {
       log.error(`Couldn't read the --inpaint mask at ${opts.inpaintUrl}.`);
@@ -9000,7 +9368,7 @@ async function reportGlassTerminal(view, outDir, log, json) {
     return;
   }
   await recordTerminal(view.id, "completed", files.map((f) => f.url));
-  await fs25.mkdir(outDir, { recursive: true });
+  await fs27.mkdir(outDir, { recursive: true });
   const solved = [];
   for (let i = 0; i < files.length; i++) {
     const f = files[i];
@@ -9032,8 +9400,8 @@ async function reportGlassTerminal(view, outDir, log, json) {
       });
       continue;
     }
-    const outPath = path25.join(outDir, `glass-${i + 1}.png`);
-    await fs25.writeFile(outPath, PNG4.sync.write(r.png));
+    const outPath = path27.join(outDir, `glass-${i + 1}.png`);
+    await fs27.writeFile(outPath, PNG4.sync.write(r.png));
     solved.push({
       path: outPath,
       url: f.url,
@@ -9663,8 +10031,8 @@ function writeJson(value) {
 }
 
 // src/commands/model-sub.ts
-import fs26 from "fs/promises";
-import path26 from "path";
+import fs28 from "fs/promises";
+import path28 from "path";
 var MODEL_SUBCOMMANDS = ["segment", "rig", "animate", "import"];
 function apiErrorMessage(data, fallback) {
   if (typeof data !== "object" || data === null) return fallback;
@@ -9679,29 +10047,29 @@ 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 ${path26.basename(filePath) || "the model"} as GLB first \u2014 Blender: File \u2192 Export \u2192 glTF 2.0, format "glTF Binary".`);
+    log.error(`\`import\` takes a .glb file (binary glTF 2.0). Export ${path28.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 fs26.readFile(filePath);
+    bytes = await fs28.readFile(filePath);
   } catch {
     log.error(`Couldn't read ${filePath}.`);
     return null;
   }
   if (bytes.byteLength > MODEL_IMPORT_MAX_BYTES) {
-    log.error(`${path26.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.`);
+    log.error(`${path28.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(`${path26.basename(filePath)} is not a GLB (no glTF magic). A .gltf + .bin pair must be exported as one binary .glb.`);
+    log.error(`${path28.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: path26.basename(filePath), bytes: bytes.byteLength, contentType: "model/gltf-binary" })
+    body: JSON.stringify({ filename: path28.basename(filePath), bytes: bytes.byteLength, contentType: "model/gltf-binary" })
   });
   if (printedStructuredError(minted)) return null;
   if (!minted.ok) {
@@ -9710,7 +10078,7 @@ async function importModelFile(args) {
     return null;
   }
   const { id, uploadUrl, url } = await minted.json();
-  log.dim(`  uploading ${path26.basename(filePath)} (${(bytes.byteLength / 1e6).toFixed(1)} MB)\u2026`);
+  log.dim(`  uploading ${path28.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) },
@@ -9858,7 +10226,7 @@ async function runModelAnimate(opts) {
 }
 
 // src/commands/wait.ts
-import path27 from "path";
+import path29 from "path";
 var MAX_TIMEOUT_SEC = 2e6;
 var STILL_RUNNING_EXIT = 2;
 var TERMINAL2 = /* @__PURE__ */ new Set(["completed", "failed"]);
@@ -10065,7 +10433,7 @@ async function runWaitAll(opts) {
       if (v?.status !== "completed" || !v.files?.length) continue;
       const local = localDeliveryFor("tools", { ...opts, outDir: opts.outDir ?? e.outDir }, e.prompt || e.kind);
       if (!local) continue;
-      const outDir = path27.join(path27.relative(process.cwd(), cwd) || ".", local.outDir);
+      const outDir = path29.join(path29.relative(process.cwd(), cwd) || ".", local.outDir);
       const target = { kind: e.kind, prompt: local.prompt, id: e.id, outDir };
       const missing = await undeliveredFiles(v.files, target);
       if (missing.length === 0) continue;
@@ -10177,8 +10545,8 @@ async function toRow(e, v, cwd) {
 }
 
 // src/commands/controller.ts
-import fs28 from "fs/promises";
-import path29 from "path";
+import fs30 from "fs/promises";
+import path31 from "path";
 
 // ../../packages/meshy-animation-catalog/src/index.ts
 import { createHash as createHash2 } from "crypto";
@@ -19308,9 +19676,9 @@ function searchMeshyAnimations(query, options = {}) {
 }
 
 // src/lib/anims.ts
-import fs27 from "fs/promises";
-import path28 from "path";
-var ANIMS_DEST = path28.join("public", "assets", "anims");
+import fs29 from "fs/promises";
+import path30 from "path";
+var ANIMS_DEST = path30.join("public", "assets", "anims");
 var HIDDEN_TAG = "reference";
 async function runAnims(opts) {
   const log = createLogger({ quiet: opts.quiet });
@@ -19326,7 +19694,7 @@ async function runAnims(opts) {
     printCatalog(log, manifest, selectors);
     return;
   }
-  const controllerMarker = path28.join(root, "src", "controllers", "character");
+  const controllerMarker = path30.join(root, "src", "controllers", "character");
   if (!await exists3(controllerMarker)) {
     log.error(
       `No character controller in this game (missing ${c.cyan("src/controllers/character/")}).`
@@ -19335,11 +19703,11 @@ async function runAnims(opts) {
     process.exitCode = 1;
     return;
   }
-  const destDir = path28.join(root, ANIMS_DEST);
-  const gameManifestPath = path28.join(destDir, "manifest.json");
+  const destDir = path30.join(root, ANIMS_DEST);
+  const gameManifestPath = path30.join(destDir, "manifest.json");
   if (opts.reset) {
-    await fs27.rm(destDir, { recursive: true, force: true });
-    log.step(`Cleared ${c.cyan(ANIMS_DEST + path28.sep)} (--reset)`);
+    await fs29.rm(destDir, { recursive: true, force: true });
+    log.step(`Cleared ${c.cyan(ANIMS_DEST + path30.sep)} (--reset)`);
   }
   if (selectors.length === 0) {
     const installed = await readGameManifest(gameManifestPath);
@@ -19377,35 +19745,35 @@ async function runAnims(opts) {
     }
   }
   const wanted = [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
-  const cacheDir = path28.join(
+  const cacheDir = path30.join(
     opts.cacheDir ?? getAnimsCacheDir(),
     `${manifest.library}-v${manifest.version}`
   );
-  await fs27.mkdir(cacheDir, { recursive: true });
-  await fs27.mkdir(destDir, { recursive: true });
+  await fs29.mkdir(cacheDir, { recursive: true });
+  await fs29.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 = path28.join(destDir, entry.file);
+    const dest = path30.join(destDir, entry.file);
     if (await hasSize(dest, entry.bytes)) {
       presentCount++;
       continue;
     }
     try {
-      const cached = path28.join(cacheDir, entry.file);
+      const cached = path30.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 fs27.writeFile(cached, buf);
+        await fs29.writeFile(cached, buf);
       }
-      await fs27.copyFile(cached, dest);
+      await fs29.copyFile(cached, dest);
       installedCount++;
       addedBytes += entry.bytes;
-      log.dim(`  ${path28.join(ANIMS_DEST, entry.file)} (${formatMb(entry.bytes)})`);
+      log.dim(`  ${path30.join(ANIMS_DEST, entry.file)} (${formatMb(entry.bytes)})`);
     } catch (err) {
       failures.push(`${entry.name} (${err instanceof Error ? err.message : String(err)})`);
     }
@@ -19421,13 +19789,13 @@ async function runAnims(opts) {
     version: manifest.version,
     clips: [...union].sort((a, b) => a.localeCompare(b))
   };
-  await fs27.writeFile(gameManifestPath, JSON.stringify(gameManifest, null, 2) + "\n");
+  await fs29.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 + path28.sep)}${addedBytes > 0 ? ` (+${formatMb(addedBytes)})` : ""}`
+    `${parts.join(", ")} \u2192 ${c.cyan(ANIMS_DEST + path30.sep)}${addedBytes > 0 ? ` (+${formatMb(addedBytes)})` : ""}`
   );
   for (const [selector, entries] of resolved) {
     const names2 = entries.filter((e) => !coreNames.has(e.name)).map((e) => e.name);
@@ -19459,8 +19827,8 @@ async function loadManifest(baseOverride) {
     }
   } catch {
   }
-  const snapshotPath = path28.join(getTemplatesDir(), "controllers", "assets", "anims-manifest.json");
-  const manifest = JSON.parse(await fs27.readFile(snapshotPath, "utf8"));
+  const snapshotPath = path30.join(getTemplatesDir(), "controllers", "assets", "anims-manifest.json");
+  const manifest = JSON.parse(await fs29.readFile(snapshotPath, "utf8"));
   return { manifest, source: "snapshot" };
 }
 function resolveSelectors(manifest, selectors) {
@@ -19578,21 +19946,21 @@ function printCatalog(log, manifest, selectors) {
 }
 async function readGameManifest(file) {
   try {
-    return JSON.parse(await fs27.readFile(file, "utf8"));
+    return JSON.parse(await fs29.readFile(file, "utf8"));
   } catch {
     return null;
   }
 }
 async function hasSize(file, bytes) {
   try {
-    return (await fs27.stat(file)).size === bytes;
+    return (await fs29.stat(file)).size === bytes;
   } catch {
     return false;
   }
 }
 async function exists3(p) {
   try {
-    await fs27.access(p);
+    await fs29.access(p);
     return true;
   } catch {
     return false;
@@ -19793,8 +20161,8 @@ var CONTROLLER_FILE_SETS = {
     ]
   }
 };
-var CODE_DEST = path29.join("src", "controllers");
-var ASSETS_DEST = path29.join("public", "assets");
+var CODE_DEST = path31.join("src", "controllers");
+var ASSETS_DEST = path31.join("public", "assets");
 async function runController(opts) {
   const log = createLogger({ quiet: opts.quiet });
   if (opts.kind?.trim() === "anims") {
@@ -19811,31 +20179,31 @@ async function runController(opts) {
     process.exitCode = 1;
     return;
   }
-  const srcDir = path29.join(getTemplatesDir(), "controllers");
+  const srcDir = path31.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 + path29.sep)}`);
+  log.step(`Installing the ${kind} controller into ${c.cyan(CODE_DEST + path31.sep)}`);
   const plan = [
-    ...set.code.map((rel) => ({ from: rel, rel: path29.join(CODE_DEST, rel) })),
+    ...set.code.map((rel) => ({ from: rel, rel: path31.join(CODE_DEST, rel) })),
     ...set.assets.map((rel) => ({
       from: rel,
-      rel: path29.join(ASSETS_DEST, path29.basename(rel))
+      rel: path31.join(ASSETS_DEST, path31.basename(rel))
     }))
   ];
   let copied = 0;
   let skipped = 0;
   try {
     for (const file of plan) {
-      const dest = path29.join(root, file.rel);
+      const dest = path31.join(root, file.rel);
       if (!opts.force && await exists4(dest)) {
         skipped++;
         log.dim(`  skipped ${file.rel} (exists \u2014 use --force to overwrite)`);
         continue;
       }
-      await fs28.mkdir(path29.dirname(dest), { recursive: true });
-      await fs28.copyFile(path29.join(srcDir, file.from), dest);
+      await fs30.mkdir(path31.dirname(dest), { recursive: true });
+      await fs30.copyFile(path31.join(srcDir, file.from), dest);
       copied++;
       log.dim(`  ${file.rel}`);
     }
@@ -19888,7 +20256,7 @@ async function runController(opts) {
   for (const line of set.sketch) {
     log.dim(`       ${line}`);
   }
-  if (kind === "character" && !await exists4(path29.join(root, ASSETS_DEST, "meshy-character.json"))) {
+  if (kind === "character" && !await exists4(path31.join(root, ASSETS_DEST, "meshy-character.json"))) {
     log.plain("");
     log.plain(
       `  ${stepOffset + 3}. This game has no generated character yet \u2014 ${c.cyan(
@@ -19920,9 +20288,9 @@ async function installMeshyCharacterManifest(args) {
     throw new Error("The API returned an invalid Meshy character manifest.");
   }
   assertCompleteMeshyControllerPack(manifest);
-  const destination = path29.join(args.root, ASSETS_DEST, "meshy-character.json");
-  await fs28.mkdir(path29.dirname(destination), { recursive: true });
-  await fs28.writeFile(
+  const destination = path31.join(args.root, ASSETS_DEST, "meshy-character.json");
+  await fs30.mkdir(path31.dirname(destination), { recursive: true });
+  await fs30.writeFile(
     destination,
     `${JSON.stringify(manifest, null, 2)}
 `
@@ -20067,14 +20435,14 @@ function assertCompleteMeshyControllerPack(manifest) {
 }
 async function installFallbackAvatar(args) {
   const { root, srcDir, log } = args;
-  const dest = path29.join(root, ASSETS_DEST, "avatar.vrm");
-  await fs28.mkdir(path29.dirname(dest), { recursive: true });
-  await fs28.copyFile(path29.join(srcDir, "assets", "default-avatar.vrm"), dest);
+  const dest = path31.join(root, ASSETS_DEST, "avatar.vrm");
+  await fs30.mkdir(path31.dirname(dest), { recursive: true });
+  await fs30.copyFile(path31.join(srcDir, "assets", "default-avatar.vrm"), dest);
   log.dim("  public/assets/avatar.vrm (fallback avatar \u2014 bundled CC0 default)");
 }
 async function exists4(p) {
   try {
-    await fs28.access(p);
+    await fs30.access(p);
     return true;
   } catch {
     return false;
@@ -20082,8 +20450,8 @@ async function exists4(p) {
 }
 
 // src/commands/character.ts
-import fs29 from "fs/promises";
-import path30 from "path";
+import fs31 from "fs/promises";
+import path32 from "path";
 function exactAnimation(selector) {
   const trimmed = selector.trim();
   if (/^-?\d+$/.test(trimmed)) return animationById(Number(trimmed));
@@ -20164,7 +20532,7 @@ function showAmbiguity(selector, candidates, log, json = false) {
   }
   process.exitCode = 1;
 }
-var INSTALLED_MANIFEST = path30.join("public", "assets", "meshy-character.json");
+var INSTALLED_MANIFEST = path32.join("public", "assets", "meshy-character.json");
 async function resolveAdoptTarget(selector) {
   const trimmed = selector?.trim();
   if (trimmed && !trimmed.endsWith(".json")) {
@@ -20173,7 +20541,7 @@ async function resolveAdoptTarget(selector) {
   const file = trimmed ?? INSTALLED_MANIFEST;
   let raw;
   try {
-    raw = await fs29.readFile(file, "utf8");
+    raw = await fs31.readFile(file, "utf8");
   } catch {
     return {
       ok: false,
@@ -20197,12 +20565,12 @@ async function runCharacterAdopt(opts) {
   const log = createLogger({ quiet: opts.quiet || opts.json });
   const target = await resolveAdoptTarget(opts.characterId);
   if (!target.ok) {
-    fail2(opts, target.message, "character");
+    fail3(opts, target.message, "character");
     return;
   }
   const ctx = await context(opts);
   if (!ctx) {
-    fail2(opts, "Not authorized. Run `genex init` first to sign in.", "character");
+    fail3(opts, "Not authorized. Run `genex init` first to sign in.", "character");
     return;
   }
   const ws = await resolveWorkspace();
@@ -20213,7 +20581,7 @@ async function runCharacterAdopt(opts) {
   }
   const project = await readProject();
   if (!project?.id) {
-    fail2(
+    fail3(
       opts,
       "No linked game here. Run this from the game folder that remixed the original (`genex link` if it is not linked yet).",
       "character"
@@ -20258,20 +20626,20 @@ 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]");
+    fail3(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).");
+    fail3(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.");
+    fail3(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.");
+    fail3(opts, "Not authorized. Run `genex init` first to sign in.");
     return;
   }
   const imported = await importModelFile({ apiUrl: ctx.apiUrl, token: ctx.token, filePath, log });
@@ -20298,7 +20666,7 @@ async function runCharacterImport(opts) {
     opts,
     ctx,
     kind: "character",
-    prompt: `Import ${path30.basename(filePath)} as a rigged character`,
+    prompt: `Import ${path32.basename(filePath)} as a rigged character`,
     createPath: "/api/characters/import",
     body,
     quote: price,
@@ -20334,16 +20702,16 @@ async function runCharacter(opts) {
   const references = opts.imageUrls ?? (opts.imageUrl === void 0 ? [] : [opts.imageUrl]);
   if (references.length > 0) {
     if (opts.directText) {
-      fail2(opts, "--image cannot be combined with --direct-text. Omit --direct-text to build from the supplied references.");
+      fail3(opts, "--image cannot be combined with --direct-text. Omit --direct-text to build from the supplied references.");
       return;
     }
     if (opts.candidate !== void 0 || opts.userApproved !== void 0 || opts.approveRemesh !== void 0) {
-      fail2(opts, "--image starts a one-shot character. --candidate / --user-approved / --approve-remesh belong to the guided preview/finalize flow; use --polycount for the reference character's face budget.");
+      fail3(opts, "--image starts a one-shot character. --candidate / --user-approved / --approve-remesh belong to the guided preview/finalize flow; use --polycount for the reference character's face budget.");
       return;
     }
     const prepared = await prepareCharacterImages(references);
     if (!prepared.ok) {
-      fail2(opts, prepared.error);
+      fail3(opts, prepared.error);
       return;
     }
     await runOneShotCharacter(opts, prepared.imageUrls);
@@ -20382,14 +20750,14 @@ async function prepareCharacterImages(references) {
   }
   return { ok: true, imageUrls };
 }
-function fail2(opts, message, kind = "character") {
+function fail3(opts, message, kind = "character") {
   if (opts.json) writeJson({ kind, status: "failed", error: message });
   else createLogger({ quiet: opts.quiet }).error(message);
   process.exitCode = 1;
 }
 function refuseSubcommandImages(opts) {
   if (opts.imageUrl === void 0 && !opts.imageUrls?.length) return false;
-  fail2(opts, "--image starts a new reference character; it cannot be combined with a character subcommand.");
+  fail3(opts, "--image starts a new reference character; it cannot be combined with a character subcommand.");
   return true;
 }
 function requestedBuild(opts, actionIds) {
@@ -20450,7 +20818,7 @@ async function runWorkflow(args) {
     } : (progress) => log.dim(`  ${progress}%`)
   );
   if (!view) {
-    fail2(args.opts, "Timed out waiting for the character workflow.", args.kind);
+    fail3(args.opts, "Timed out waiting for the character workflow.", args.kind);
     return;
   }
   if (view.status !== "completed") {
@@ -20464,11 +20832,11 @@ async function runCharacterConcept(opts) {
   const log = createLogger({ quiet: opts.quiet || opts.json });
   const prompt = opts.prompt?.trim();
   if (!prompt) {
-    fail2(opts, 'Missing brief. Usage: genex character "<brief>".', "character_concept");
+    fail3(opts, 'Missing brief. Usage: genex character "<brief>".', "character_concept");
     return;
   }
   if (prompt.length > CHARACTER_BRIEF_MAX_CHARS) {
-    fail2(
+    fail3(
       opts,
       `The brief is ${prompt.length} characters \u2014 the character concept endpoint caps it at ${CHARACTER_BRIEF_MAX_CHARS}. Tighten it to the look that matters (silhouette, materials, palette, mood); gameplay details don't belong in the brief.`,
       "character_concept"
@@ -20476,15 +20844,15 @@ async function runCharacterConcept(opts) {
     return;
   }
   if (opts.polycount !== void 0) {
-    fail2(opts, "--polycount is only available with --direct-text or --image. The approval flow takes its face budget on `character finalize --approve-remesh <faces>`.", "character_concept");
+    fail3(opts, "--polycount is only available with --direct-text or --image. 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` / `character --image` / `creature` (one shot). Concepts are images.", "character_concept");
+    fail3(opts, "--texture / --no-ultra / --pose apply to the paid mesh call: pass them to `character preview` (guided) or `character --direct-text` / `character --image` / `creature` (one shot). Concepts are images.", "character_concept");
     return;
   }
   if (opts.controllerPack === false) {
-    fail2(opts, "--no-controller-pack is only available with --direct-text or --image. The guided Meshy parity flow always installs neutral-v3.", "character_concept");
+    fail3(opts, "--no-controller-pack is only available with --direct-text or --image. The guided Meshy parity flow always installs neutral-v3.", "character_concept");
     return;
   }
   const resolved = resolveActionSelectors(opts.actions ?? []);
@@ -20494,7 +20862,7 @@ async function runCharacterConcept(opts) {
   }
   const ctx = await context(opts);
   if (!ctx) {
-    fail2(opts, "Not authorized. Run `genex init` first to sign in.", "character_concept");
+    fail3(opts, "Not authorized. Run `genex init` first to sign in.", "character_concept");
     return;
   }
   const build = requestedBuild(opts, resolved.actionIds);
@@ -20505,7 +20873,7 @@ async function runCharacterConcept(opts) {
     return;
   }
   if (price.candidateCount !== 3) {
-    fail2(opts, `The concept quote returned ${price.candidateCount} candidates; this workflow requires exactly 3.`, "character_concept");
+    fail3(opts, `The concept quote returned ${price.candidateCount} candidates; this workflow requires exactly 3.`, "character_concept");
     return;
   }
   if (!opts.json) {
@@ -20533,20 +20901,20 @@ async function runOneShotCharacter(opts, imageUrls) {
   const log = createLogger({ quiet: opts.quiet || opts.json });
   const prompt = opts.prompt?.trim() || (imageUrls ? "Character from supplied reference images" : void 0);
   if (!prompt) {
-    fail2(opts, 'Missing prompt. Usage: genex character "<prompt>" --direct-text.');
+    fail3(opts, 'Missing prompt. Usage: genex character "<prompt>" --direct-text.');
     return;
   }
   const badTexture = badCharacterTexture(opts);
   if (badTexture) {
-    fail2(opts, badTexture);
+    fail3(opts, badTexture);
     return;
   }
   if (opts.polycount !== void 0 && (!Number.isInteger(opts.polycount) || opts.polycount < REMESH_TARGET_MIN || opts.polycount > REMESH_TARGET_MAX)) {
-    fail2(opts, `--polycount must be an integer between ${REMESH_TARGET_MIN} and ${REMESH_TARGET_MAX}.`);
+    fail3(opts, `--polycount must be an integer between ${REMESH_TARGET_MIN} and ${REMESH_TARGET_MAX}.`);
     return;
   }
   if (opts.pose !== void 0 && !["a-pose", "t-pose"].includes(opts.pose)) {
-    fail2(opts, "--pose must be a-pose or t-pose.");
+    fail3(opts, "--pose must be a-pose or t-pose.");
     return;
   }
   const resolved = resolveActionSelectors(opts.actions ?? []);
@@ -20556,7 +20924,7 @@ async function runOneShotCharacter(opts, imageUrls) {
   }
   const ctx = await context(opts);
   if (!ctx) {
-    fail2(opts, "Not authorized. Run `genex init` first to sign in.");
+    fail3(opts, "Not authorized. Run `genex init` first to sign in.");
     return;
   }
   const controllerPack = opts.controllerPack !== false;
@@ -20575,7 +20943,7 @@ async function runOneShotCharacter(opts, imageUrls) {
     return;
   }
   if (imageUrls && price.referenceImageCount !== imageUrls.length) {
-    fail2(opts, "This server did not confirm support for all character reference images. No generation was started. Update the Genex API to a version supporting character --image, then run this command.");
+    fail3(opts, "This server did not confirm support for all character reference images. No generation was started. Update the Genex API to a version supporting character --image, then run this command.");
     return;
   }
   if (!opts.json) {
@@ -20619,25 +20987,25 @@ async function runCharacterPreview(opts) {
   const log = createLogger({ quiet: opts.quiet || opts.json });
   const conceptId = opts.conceptId?.trim();
   if (!conceptId) {
-    fail2(opts, "Missing concept id. Usage: genex character preview <concept-id> --candidate <1|2|3> --user-approved.", "character_preview");
+    fail3(opts, "Missing concept id. Usage: genex character preview <concept-id> --candidate <1|2|3> --user-approved.", "character_preview");
     return;
   }
   if (!Number.isInteger(opts.candidate) || ![1, 2, 3].includes(opts.candidate)) {
-    fail2(opts, "--candidate must be exactly 1, 2, or 3.", "character_preview");
+    fail3(opts, "--candidate must be exactly 1, 2, or 3.", "character_preview");
     return;
   }
   if (opts.userApproved !== true) {
-    fail2(opts, "STOP: preview creation requires the user's explicit selection. Re-run with --user-approved only after they choose this candidate.", "character_preview");
+    fail3(opts, "STOP: preview creation requires the user's explicit selection. Re-run with --user-approved only after they choose this candidate.", "character_preview");
     return;
   }
   const ctx = await context(opts);
   if (!ctx) {
-    fail2(opts, "Not authorized. Run `genex init` first to sign in.", "character_preview");
+    fail3(opts, "Not authorized. Run `genex init` first to sign in.", "character_preview");
     return;
   }
   const badTexture = badCharacterTexture(opts);
   if (badTexture) {
-    fail2(opts, badTexture, "character_preview");
+    fail3(opts, badTexture, "character_preview");
     return;
   }
   const body = { candidateIndex: opts.candidate, userApproved: true, ...meshyQualityOptions(opts) };
@@ -20673,31 +21041,31 @@ async function runCharacterFinalize(opts) {
   const log = createLogger({ quiet: opts.quiet || opts.json });
   const previewId = opts.previewId?.trim();
   if (!previewId) {
-    fail2(opts, "Missing preview id. Usage: genex character finalize <preview-id> --user-approved --approve-remesh 10000.");
+    fail3(opts, "Missing preview id. Usage: genex character finalize <preview-id> --user-approved --approve-remesh 10000.");
     return;
   }
   if (opts.userApproved !== true) {
-    fail2(opts, "STOP: finalization requires explicit user approval of all four preview views. Re-run with --user-approved only after approval.");
+    fail3(opts, "STOP: finalization requires explicit user approval of all four preview views. Re-run with --user-approved only after approval.");
     return;
   }
   const remeshTarget = opts.approveRemesh;
   if (remeshTarget === void 0 || !Number.isInteger(remeshTarget) || remeshTarget < REMESH_TARGET_MIN || remeshTarget > REMESH_TARGET_MAX) {
-    fail2(
+    fail3(
       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 <faces> is the rigging-copy target.");
+    fail3(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.");
+    fail3(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) {
-    fail2(opts, "--no-controller-pack is only available with --direct-text or --image. Guided finalization requires neutral-v3.");
+    fail3(opts, "--no-controller-pack is only available with --direct-text or --image. Guided finalization requires neutral-v3.");
     return;
   }
   const resolved = resolveActionSelectors(opts.actions ?? []);
@@ -20707,7 +21075,7 @@ async function runCharacterFinalize(opts) {
   }
   const ctx = await context(opts);
   if (!ctx) {
-    fail2(opts, "Not authorized. Run `genex init` first to sign in.");
+    fail3(opts, "Not authorized. Run `genex init` first to sign in.");
     return;
   }
   const body = {
@@ -20843,22 +21211,22 @@ async function context2(opts) {
   if (!token) return null;
   return { token, apiUrl };
 }
-async function readVideo(path44, log) {
+async function readVideo(path46, log) {
   let bytes;
   try {
-    bytes = await readFile(path44);
+    bytes = await readFile(path46);
   } catch {
-    log.error(`Can't read ${path44}.`);
+    log.error(`Can't read ${path46}.`);
     return null;
   }
   if (bytes.byteLength > MAX_VIDEO_BYTES) {
-    log.error(`${basename(path44)} is ${(bytes.byteLength / 1e6).toFixed(0)} MB \u2014 the limit is ${MAX_VIDEO_BYTES / 1e6} MB.`);
+    log.error(`${basename(path46)} 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, path44, bytes, log) {
-  const contentType = /\.mov$/i.test(path44) ? "video/quicktime" : "video/mp4";
+async function uploadVideo(apiUrl, token, characterId, path46, bytes, log) {
+  const contentType = /\.mov$/i.test(path46) ? "video/quicktime" : "video/mp4";
   const minted = await apiFetch(
     `${apiUrl}/api/characters/${encodeURIComponent(characterId)}/motions/video-url`,
     {
@@ -20873,7 +21241,7 @@ async function uploadVideo(apiUrl, token, characterId, path44, bytes, log) {
     return null;
   }
   const { uploadUrl, videoUrl } = await minted.json();
-  log.dim(`  uploading ${basename(path44)} (${(bytes.byteLength / 1e6).toFixed(1)} MB)\u2026`);
+  log.dim(`  uploading ${basename(path46)} (${(bytes.byteLength / 1e6).toFixed(1)} MB)\u2026`);
   const put = await fetch(uploadUrl, {
     method: "PUT",
     headers: { "Content-Type": contentType, "Content-Length": String(bytes.byteLength) },
@@ -21205,8 +21573,8 @@ function rank(items, query) {
 }
 
 // src/commands/motion.ts
-import fs30 from "fs/promises";
-import path31 from "path";
+import fs32 from "fs/promises";
+import path33 from "path";
 
 // src/lib/motion/npz.ts
 import zlib from "zlib";
@@ -22457,7 +22825,7 @@ async function motionGen(opts, log) {
   }
   if (opts.constraintsPath !== void 0) {
     try {
-      const raw = await fs30.readFile(opts.constraintsPath, "utf8");
+      const raw = await fs32.readFile(opts.constraintsPath, "utf8");
       generationOptions.constraints = JSON.parse(raw);
     } catch {
       log.error(`Couldn't read the --constraints JSON at ${opts.constraintsPath}.`);
@@ -22481,10 +22849,10 @@ async function motionGen(opts, log) {
 async function expandTakes(selectors) {
   const out = [];
   for (const sel of selectors) {
-    const st = await fs30.stat(sel).catch(() => null);
+    const st = await fs32.stat(sel).catch(() => null);
     if (st?.isDirectory()) {
-      const names2 = await fs30.readdir(sel);
-      for (const n of names2.sort()) if (n.endsWith(".npz")) out.push(path31.join(sel, n));
+      const names2 = await fs32.readdir(sel);
+      for (const n of names2.sort()) if (n.endsWith(".npz")) out.push(path33.join(sel, n));
     } else if (st?.isFile()) {
       out.push(sel);
     } else {
@@ -22519,7 +22887,7 @@ async function motionVerify(opts, log) {
   let gates = DEFAULT_GATES;
   if (opts.gatesPath) {
     try {
-      gates = mergeGates(DEFAULT_GATES, JSON.parse(await fs30.readFile(opts.gatesPath, "utf8")));
+      gates = mergeGates(DEFAULT_GATES, JSON.parse(await fs32.readFile(opts.gatesPath, "utf8")));
     } catch {
       log.error(`Couldn't read the --gates JSON at ${opts.gatesPath}.`);
       process.exitCode = 1;
@@ -22541,9 +22909,9 @@ async function motionVerify(opts, log) {
   }
   const reports = [];
   for (const file of files) {
-    const stem = path31.basename(file).replace(/\.npz$/, "");
+    const stem = path33.basename(file).replace(/\.npz$/, "");
     try {
-      reports.push(analyzeTake(stem, await fs30.readFile(file), gates));
+      reports.push(analyzeTake(stem, await fs32.readFile(file), gates));
     } catch (err) {
       reports.push({
         take: stem,
@@ -22581,7 +22949,7 @@ async function motionCompile(opts, log) {
   let cfg = DEFAULT_MOTION_CONFIG;
   if (opts.configPath) {
     try {
-      const patch = JSON.parse(await fs30.readFile(opts.configPath, "utf8"));
+      const patch = JSON.parse(await fs32.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}.`);
@@ -22599,16 +22967,16 @@ async function motionCompile(opts, log) {
   }
   const inputs = [];
   for (const file of files) {
-    const stem = path31.basename(file).replace(/\.npz$/, "");
+    const stem = path33.basename(file).replace(/\.npz$/, "");
     try {
-      inputs.push({ stem, take: loadTake(await fs30.readFile(file)) });
+      inputs.push({ stem, take: loadTake(await fs32.readFile(file)) });
     } catch (err) {
       log.error(`${stem}: ${err instanceof Error ? err.message : String(err)}`);
       process.exitCode = 1;
       return;
     }
   }
-  const setName = opts.set ?? path31.basename(opts.out).replace(/\.json$/, "");
+  const setName = opts.set ?? path33.basename(opts.out).replace(/\.json$/, "");
   let result;
   try {
     result = compileSet(inputs, setName, cfg);
@@ -22623,9 +22991,9 @@ async function motionCompile(opts, log) {
     process.exitCode = 1;
     return;
   }
-  await fs30.mkdir(path31.dirname(path31.resolve(opts.out)), { recursive: true });
+  await fs32.mkdir(path33.dirname(path33.resolve(opts.out)), { recursive: true });
   const json = JSON.stringify(result.data);
-  await fs30.writeFile(opts.out, json);
+  await fs32.writeFile(opts.out, json);
   if (opts.json) {
     writeJson({ out: opts.out, set: setName, tracks: Object.keys(result.data.gaits), bytes: json.length });
     return;
@@ -22643,9 +23011,9 @@ var MOTION_RUNTIME_FILES = [
 var MOTION_PRESETS = {
   rifle: ["sets/rifle.json", "sets/jumps.json"]
 };
-var MOTION_DEST = path31.join("src", "motion");
+var MOTION_DEST = path33.join("src", "motion");
 async function motionInstall(opts, log) {
-  const srcDir = path31.join(getTemplatesDir(), "motion");
+  const srcDir = path33.join(getTemplatesDir(), "motion");
   const root = opts.cwd ?? process.cwd();
   const preset = opts.set;
   if (preset !== void 0 && !MOTION_PRESETS[preset]) {
@@ -22656,21 +23024,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 + path31.sep)}`);
+  log.step(`Vendoring the motion runtime into ${c.cyan(MOTION_DEST + path33.sep)}`);
   let copied = 0, skipped = 0;
   try {
     for (const rel of files) {
-      const dest = path31.join(root, MOTION_DEST, rel);
-      const exists5 = await fs30.access(dest).then(() => true, () => false);
+      const dest = path33.join(root, MOTION_DEST, rel);
+      const exists5 = await fs32.access(dest).then(() => true, () => false);
       if (!opts.force && exists5) {
         skipped++;
-        log.dim(`  skipped ${path31.join(MOTION_DEST, rel)} (exists \u2014 use --force to overwrite)`);
+        log.dim(`  skipped ${path33.join(MOTION_DEST, rel)} (exists \u2014 use --force to overwrite)`);
         continue;
       }
-      await fs30.mkdir(path31.dirname(dest), { recursive: true });
-      await fs30.copyFile(path31.join(srcDir, rel), dest);
+      await fs32.mkdir(path33.dirname(dest), { recursive: true });
+      await fs32.copyFile(path33.join(srcDir, rel), dest);
       copied++;
-      log.dim(`  ${path31.join(MOTION_DEST, rel)}`);
+      log.dim(`  ${path33.join(MOTION_DEST, rel)}`);
     }
   } catch (err) {
     log.error(`Copy failed: ${String(err)}`);
@@ -22711,7 +23079,7 @@ async function motionConstraints(opts, log) {
   }
   const doc = directionConstraint(dir, speed, duration);
   const out = opts.out ?? "constraints.json";
-  await fs30.writeFile(out, JSON.stringify(doc));
+  await fs32.writeFile(out, JSON.stringify(doc));
   if (opts.json) {
     writeJson({ out, dir: dirName, speed, duration, waypoints: doc[0].frame_indices.length });
     return;
@@ -22748,14 +23116,14 @@ async function runMotion(opts) {
 }
 
 // src/commands/blender.ts
-import fs31 from "fs/promises";
-import path32 from "path";
+import fs33 from "fs/promises";
+import path34 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 fs31.mkdir(dir, { recursive: true });
-  const p = path32.join(dir, name);
-  await fs31.writeFile(p, Buffer.from(b64, "base64"));
+  await fs33.mkdir(dir, { recursive: true });
+  const p = path34.join(dir, name);
+  await fs33.writeFile(p, Buffer.from(b64, "base64"));
   return p;
 }
 function reportScene(log, s) {
@@ -22781,7 +23149,7 @@ async function runBlender(opts) {
     return serveLocalBlender({ port, log });
   }
   if (sub === "mcp") {
-    const { runBlenderMcp } = await import("./blender-mcp-ATHMMRDU.js");
+    const { runBlenderMcp } = await import("./blender-mcp-ZRCMYTXI.js");
     return runBlenderMcp();
   }
   if (sub === "seat") {
@@ -22839,7 +23207,7 @@ async function runBlender(opts) {
     log.plain(rest.join("\n"));
     return 1;
   }
-  const outDir = path32.resolve(opts.outDir ?? DEFAULT_OUT_DIR);
+  const outDir = path34.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(", ")}.`);
@@ -22879,14 +23247,14 @@ async function runBlender(opts) {
       return 0;
     }
     case "export": {
-      const target = opts.out ?? path32.join(outDir, "scene.glb");
+      const target = opts.out ?? path34.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 fs31.mkdir(path32.dirname(target), { recursive: true });
-      await fs31.writeFile(target, Buffer.from(r.glbBase64, "base64"));
+      await fs33.mkdir(path34.dirname(target), { recursive: true });
+      await fs33.writeFile(target, Buffer.from(r.glbBase64, "base64"));
       log.success(`Exported ${r.bytes ?? 0} bytes`);
       log.plain(`  ${c.cyan(target)}`);
       return 0;
@@ -22919,12 +23287,12 @@ async function runBlender(opts) {
           return 1;
         }
         try {
-          script = await fs31.readFile(opts.input, "utf8");
+          script = await fs33.readFile(opts.input, "utf8");
         } catch {
           log.error(`Can't read ${opts.input}`);
           return 1;
         }
-        label = path32.basename(opts.input);
+        label = path34.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());
@@ -23043,9 +23411,9 @@ print(f"castle: {n} objects")
 `;
 
 // src/commands/asset-new.ts
-import fs32 from "fs";
+import fs34 from "fs";
 import fsp from "fs/promises";
-import path33 from "path";
+import path35 from "path";
 import { pathToFileURL } from "url";
 var EXTRA_FILES = [
   "genex-asset.example.json",
@@ -23139,7 +23507,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 ? path33.resolve(options.dir) : process.cwd();
+  const cwd = options.dir ? path35.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>]');
@@ -23149,14 +23517,14 @@ async function runAssetNew(options) {
     log.error(`The slug must be kebab-case (letters, digits, dashes), got: ${slug}`);
     return 1;
   }
-  const templateDir = path33.join(getTemplatesDir(), "asset-viewer");
-  if (!fs32.existsSync(templateDir)) {
+  const templateDir = path35.join(getTemplatesDir(), "asset-viewer");
+  if (!fs34.existsSync(templateDir)) {
     log.error(`Vendored asset-viewer template not found at ${templateDir} \u2014 reinstall the CLI.`);
     return 1;
   }
-  const manifestTools = await import(pathToFileURL(path33.join(templateDir, "tools", "emit-manifest.mjs")).href);
+  const manifestTools = await import(pathToFileURL(path35.join(templateDir, "tools", "emit-manifest.mjs")).href);
   const { SHARED_FILES, PARITY_FILENAME, hashSharedFiles, pascalCase } = manifestTools;
-  const lockPath = path33.join(templateDir, "shared-files.sha256.json");
+  const lockPath = path35.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]);
@@ -23169,8 +23537,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 = path33.resolve(cwd, options.out ?? slug);
-  if (fs32.existsSync(outDir) && fs32.readdirSync(outDir).length > 0 && !options.force) {
+  const outDir = path35.resolve(cwd, options.out ?? slug);
+  if (fs34.existsSync(outDir) && fs34.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;
   }
@@ -23198,24 +23566,24 @@ async function runAssetNew(options) {
   };
   await fsp.mkdir(outDir, { recursive: true });
   for (const rel of [...SHARED_FILES, ...EXTRA_FILES]) {
-    const to = path33.join(outDir, rel);
-    await fsp.mkdir(path33.dirname(to), { recursive: true });
-    await fsp.copyFile(path33.join(templateDir, rel), to);
+    const to = path35.join(outDir, rel);
+    await fsp.mkdir(path35.dirname(to), { recursive: true });
+    await fsp.copyFile(path35.join(templateDir, rel), to);
   }
-  const pkg = fillTemplate(await fsp.readFile(path33.join(templateDir, "package.json"), "utf8"), {
+  const pkg = fillTemplate(await fsp.readFile(path35.join(templateDir, "package.json"), "utf8"), {
     slug,
     name,
     version
   });
-  await fsp.writeFile(path33.join(outDir, "package.json"), pkg, "utf8");
-  await fsp.writeFile(path33.join(outDir, "asset.config.json"), JSON.stringify(config, null, 2) + "\n", "utf8");
-  await fsp.writeFile(path33.join(outDir, ".gitignore"), GITIGNORE, "utf8");
+  await fsp.writeFile(path35.join(outDir, "package.json"), pkg, "utf8");
+  await fsp.writeFile(path35.join(outDir, "asset.config.json"), JSON.stringify(config, null, 2) + "\n", "utf8");
+  await fsp.writeFile(path35.join(outDir, ".gitignore"), GITIGNORE, "utf8");
   await fsp.writeFile(
-    path33.join(outDir, "DESIGN.md"),
+    path35.join(outDir, "DESIGN.md"),
     designDoc({ name, slug, sizeMeters, triBand, holder }),
     "utf8"
   );
-  const placeholder = await fsp.readFile(path33.join(templateDir, "src", "asset", "PLACEHOLDER.ts"), "utf8");
+  const placeholder = await fsp.readFile(path35.join(templateDir, "src", "asset", "PLACEHOLDER.ts"), "utf8");
   const seeded = seedAssetSource(placeholder, {
     slug,
     name,
@@ -23226,8 +23594,8 @@ async function runAssetNew(options) {
     pascalCase
   });
   const assetFilename = `${slug.replace(/-([a-z0-9])/g, (_, ch) => ch.toUpperCase())}.ts`;
-  await fsp.mkdir(path33.join(outDir, "src", "asset"), { recursive: true });
-  await fsp.writeFile(path33.join(outDir, "src", "asset", assetFilename), seeded, "utf8");
+  await fsp.mkdir(path35.join(outDir, "src", "asset"), { recursive: true });
+  await fsp.writeFile(path35.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) {
@@ -23235,7 +23603,7 @@ async function runAssetNew(options) {
     return 1;
   }
   await fsp.writeFile(
-    path33.join(outDir, PARITY_FILENAME),
+    path35.join(outDir, PARITY_FILENAME),
     JSON.stringify(
       {
         note: "Recorded by `genex asset new`. Gate G13 recomputes these; do not hand-edit the viewer.",
@@ -23279,14 +23647,14 @@ async function runAssetNew(options) {
 }
 
 // src/commands/tools.ts
-import path36 from "path";
+import path38 from "path";
 
 // src/commands/doctor.ts
-import path35 from "path";
+import path37 from "path";
 
 // src/commands/llm.ts
-import fs33 from "fs/promises";
-import path34 from "path";
+import fs35 from "fs/promises";
+import path36 from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 var SUBS3 = ["models", "bench", "price", "status", "cancel"];
 var LLM_BENCH_APPROVAL_REQUIRED = "STOP: `genex llm bench` runs the real model and spends YOUR OWN credits \u2014 your balance, not a player's, and a spend this build's asset allowance does not count. Re-run with --max-credits <n> --user-approved only after the person at the keyboard agreed to the number.";
@@ -23429,13 +23797,13 @@ async function runLlm(opts = {}) {
   const log = createLogger({ quiet: opts.quiet || opts.json });
   const cwd = opts.cwd ?? process.cwd();
   const sub = opts.name?.trim() || "models";
-  const fail4 = (command, message, extra = {}) => {
+  const fail5 = (command, message, extra = {}) => {
     if (opts.json) writeJsonLine({ command, status: "failed", error: message, ...extra });
     else log.error(message);
     process.exitCode = 1;
   };
   if (!SUBS3.includes(sub)) {
-    fail4(`llm ${sub}`, `Unknown subcommand ${sub}. Use: ${SUBS3.join(", ")}.`);
+    fail5(`llm ${sub}`, `Unknown subcommand ${sub}. Use: ${SUBS3.join(", ")}.`);
     return;
   }
   if (sub === "price") {
@@ -23446,31 +23814,31 @@ async function runLlm(opts = {}) {
   const toolsOnly = ws.mode === "tools" && !ws.hosted;
   const projectBound = sub === "bench" || sub === "status" || sub === "cancel";
   if (sub === "cancel" && !opts.generationId?.trim()) {
-    fail4("llm cancel", "`genex llm cancel` needs the id of the call to stop, e.g. genex llm cancel <id> \u2014 `genex llm status` lists the open ones.");
+    fail5("llm cancel", "`genex llm cancel` needs the id of the call to stop, e.g. genex llm cancel <id> \u2014 `genex llm status` lists the open ones.");
     return;
   }
   if (sub === "bench") {
     if (opts.maxCoins !== void 0) process.stderr.write(`${c.yellow("!")} ${LLM_MAX_COINS_DEPRECATED}
 `);
     if (opts.maxCoins !== void 0 && opts.maxCredits !== void 0 && opts.maxCoins !== opts.maxCredits) {
-      fail4("llm bench", `Pass --max-credits alone \u2014 --max-coins is its deprecated name, and the two disagree (${opts.maxCredits} vs ${opts.maxCoins}).`);
+      fail5("llm bench", `Pass --max-credits alone \u2014 --max-coins is its deprecated name, and the two disagree (${opts.maxCredits} vs ${opts.maxCoins}).`);
       return;
     }
     const approvedCredits = opts.maxCredits ?? opts.maxCoins;
     if (approvedCredits === void 0 || opts.userApproved !== true) {
-      fail4("llm bench", LLM_BENCH_APPROVAL_REQUIRED);
+      fail5("llm bench", LLM_BENCH_APPROVAL_REQUIRED);
       return;
     }
     if (!Number.isInteger(approvedCredits) || approvedCredits < 1) {
-      fail4("llm bench", `--max-credits takes a whole number of credits, 1 or more (got ${String(approvedCredits)}).`);
+      fail5("llm bench", `--max-credits takes a whole number of credits, 1 or more (got ${String(approvedCredits)}).`);
       return;
     }
     if (!opts.benchPrompt?.trim()) {
-      fail4("llm bench", '`genex llm bench` needs the prompt your game would send, e.g. genex llm bench "<prompt>" --max-credits <n> --user-approved.');
+      fail5("llm bench", '`genex llm bench` needs the prompt your game would send, e.g. genex llm bench "<prompt>" --max-credits <n> --user-approved.');
       return;
     }
     if (opts.jsonOutput && opts.textOutput) {
-      fail4("llm bench", "Pass --json-output or --text, not both.");
+      fail5("llm bench", "Pass --json-output or --text, not both.");
       return;
     }
   }
@@ -23486,7 +23854,7 @@ async function runLlm(opts = {}) {
   }
   const meta = await readProject(cwd);
   if (projectBound && !meta?.id) {
-    fail4(
+    fail5(
       `llm ${sub}`,
       sub === "bench" ? "This folder isn't linked to a game \u2014 a benchmark is billed to a project you own." : `This folder isn't linked to a game \u2014 \`genex llm ${sub}\` works on the development calls of a project you own.`
     );
@@ -23499,7 +23867,7 @@ async function runLlm(opts = {}) {
   let token = opts.token ?? await readUserToken(opts.envPath, apiUrl);
   if (!token) {
     if (opts.noAuth) {
-      fail4(`llm ${sub}`, "Not signed in. Re-run without --no-auth to connect.");
+      fail5(`llm ${sub}`, "Not signed in. Re-run without --no-auth to connect.");
       return;
     }
     log.plain("Not signed in \u2014 connecting\u2026");
@@ -23516,7 +23884,7 @@ async function runLlm(opts = {}) {
         log.dim(`Then re-run ${c.cyan(`genex llm ${sub}`)}.`);
         return;
       }
-      fail4(`llm ${sub}`, `Sign-in didn't complete: ${err instanceof Error ? err.message : String(err)}`);
+      fail5(`llm ${sub}`, `Sign-in didn't complete: ${err instanceof Error ? err.message : String(err)}`);
       return;
     }
     await writeUserToken(token, opts.envPath, apiUrl);
@@ -23807,7 +24175,7 @@ async function runBench(args) {
   let schema;
   if (opts.schemaPath) {
     try {
-      schema = JSON.parse(await fs33.readFile(path34.resolve(cwd, opts.schemaPath), "utf8"));
+      schema = JSON.parse(await fs35.readFile(path36.resolve(cwd, opts.schemaPath), "utf8"));
     } catch (err) {
       benchFailed(opts, log, `Couldn't read --schema ${opts.schemaPath}: ${err instanceof Error ? err.message : String(err)}`);
       return;
@@ -23873,7 +24241,7 @@ async function runBench(args) {
   }
   const base = `${apiUrl}/api/runtime/development/projects/${encodeURIComponent(projectId)}/generations`;
   const results = [];
-  let refusal = null;
+  let refusal2 = null;
   let providerRefused = 0;
   let inflight = null;
   const onSigint = () => {
@@ -23906,7 +24274,7 @@ async function runBench(args) {
       });
       if (!res.ok) {
         const verdict = await explainBenchRefusal(res, call, base, log, opts, i, results.length);
-        if (verdict.refusal) refusal = verdict.refusal;
+        if (verdict.refusal) refusal2 = verdict.refusal;
         if (verdict.stop) break;
         continue;
       }
@@ -24003,7 +24371,7 @@ async function runBench(args) {
       results,
       // The create-time refusal that ended the run, or null. Beside the
       // samples, never among them: no attempt existed and nothing was spent.
-      refusal,
+      refusal: refusal2,
       // Over the settled samples: the real provider cost (pico-dollar strings
       // and USD) and the whole credits charged.
       costUsdPicos: record.cost,
@@ -24125,40 +24493,40 @@ async function explainBenchRefusal(res, call, base, log, opts, index, settledSoF
     return { stop: true, refusal: { status: res.status, error: typeof printed2.error === "string" ? printed2.error : null, slotsHeld: null, slotLimit: null } };
   }
   const body = await res.json().catch(() => ({}));
-  const refusal = { status: res.status, error: body.error ?? null, slotsHeld: null, slotLimit: null };
+  const refusal2 = { status: res.status, error: body.error ?? null, slotsHeld: null, slotLimit: null };
   if (res.status === 429 && body.error === "generation_limit") {
     const counts = serverSlotCounts(body) ?? await readSlotCounts(call, base);
-    refusal.slotsHeld = counts?.held ?? null;
-    refusal.slotLimit = counts?.limit ?? null;
+    refusal2.slotsHeld = counts?.held ?? null;
+    refusal2.slotLimit = counts?.limit ?? null;
     if (!opts.json) log.error(`  Sample ${index + 1} ${benchSlotsHeldSentence(counts)}`);
-    return { stop: true, refusal };
+    return { stop: true, refusal: refusal2 };
   }
   if (res.status === 403 && body.error === "credits_unverified") {
     if (!opts.json) log.error(`  ${LLM_BENCH_UNVERIFIED_LINE}`);
-    return { stop: true, refusal };
+    return { stop: true, refusal: refusal2 };
   }
-  if (opts.json) return { stop: res.status !== 429, refusal };
+  if (opts.json) return { stop: res.status !== 429, refusal: refusal2 };
   if (res.status === 404 && body.error === "not_found") {
     log.error(`  ${LLM_LANE_OFF_LINE}`);
-    return { stop: true, refusal };
+    return { stop: true, refusal: refusal2 };
   }
   if (res.status === 403 && body.error === "credential_scope") {
     log.error("  This credential can't reach the runtime lane \u2014 an API key or MCP token is scoped out.");
     log.dim(`  Sign in with ${c.cyan("genex auth")} and re-run.`);
-    return { stop: true, refusal };
+    return { stop: true, refusal: refusal2 };
   }
   if (res.status === 403 && body.error === "project_owner_required") {
     log.error("  A benchmark is billed to a project YOU own, and this one isn't yours.");
-    return { stop: true, refusal };
+    return { stop: true, refusal: refusal2 };
   }
   if (res.status === 402) {
     log.error("  Not enough credits to start the attempt \u2014 a bench is paid from your own balance.");
-    return { stop: true, refusal };
+    return { stop: true, refusal: refusal2 };
   }
   log.error(
     `  Sample ${index + 1} was refused: ${body.message ?? body.error ?? `HTTP ${res.status}`}${settledSoFar > 0 ? " (earlier samples still count)" : ""}`
   );
-  return { stop: res.status >= 500 || res.status === 401 || res.status === 403, refusal };
+  return { stop: res.status >= 500 || res.status === 401 || res.status === 403, refusal: refusal2 };
 }
 function printProviderRefusal(log, status2, message, awaitingBill = false) {
   if (awaitingBill) log.dim(`      The provider answered ${status2} after routing \u2014 its bill is not final, so what this call reserved stays held until it resolves (see \`genex llm status\`); it is not a sample.`);
@@ -24189,9 +24557,9 @@ async function pollSettled(call, url, timeoutSec) {
 }
 async function saveBench(cwd, record) {
   try {
-    const file = path34.join(cwd, LLM_BENCH_FILE);
-    await fs33.mkdir(path34.dirname(file), { recursive: true });
-    await fs33.writeFile(file, JSON.stringify(record, null, 2) + "\n");
+    const file = path36.join(cwd, LLM_BENCH_FILE);
+    await fs35.mkdir(path36.dirname(file), { recursive: true });
+    await fs35.writeFile(file, JSON.stringify(record, null, 2) + "\n");
     return LLM_BENCH_FILE;
   } catch {
     return null;
@@ -24404,7 +24772,7 @@ async function cancelCall(args) {
 async function readSavedBench(cwd) {
   let parsed;
   try {
-    parsed = JSON.parse(await fs33.readFile(path34.join(cwd, LLM_BENCH_FILE), "utf8"));
+    parsed = JSON.parse(await fs35.readFile(path36.join(cwd, LLM_BENCH_FILE), "utf8"));
   } catch {
     return null;
   }
@@ -24836,7 +25204,7 @@ async function fetchLegalStatus(apiUrl, token) {
 }
 async function firstSkillsMarker() {
   for (const target of resolveAgentTargets()) {
-    const marker = await readSkillsMarker(path35.join(target.baseDir, "skills"));
+    const marker = await readSkillsMarker(path37.join(target.baseDir, "skills"));
     if (marker) return marker;
   }
   return null;
@@ -24887,8 +25255,8 @@ async function runTools(opts) {
   let totalNew = 0;
   let totalUpdated = 0;
   for (const t of targets) {
-    const dest = path36.join(t.baseDir, "skills");
-    const { copied, updated } = await copyTemplates(path36.join(templatesDir, "skills"), dest, {
+    const dest = path38.join(t.baseDir, "skills");
+    const { copied, updated } = await copyTemplates(path38.join(templatesDir, "skills"), dest, {
       filter: (rel) => skillFamilyFilter("tools")(`skills/${rel}`)
     });
     await pruneRemovedSkills(dest, log);
@@ -24948,8 +25316,8 @@ async function runTools(opts) {
 }
 
 // src/commands/budget.ts
-import fs34 from "fs/promises";
-import path37 from "path";
+import fs36 from "fs/promises";
+import path39 from "path";
 var BUDGET_SOURCE_LINE = "Live from your account; prices can change without a deploy.";
 var BUDGET_APPROVAL_REQUIRED = "STOP: raising the asset allowance requires the player's explicit approval. Re-run with --user-approved only after they agreed to the number.";
 function internalKind(kind) {
@@ -24957,7 +25325,7 @@ function internalKind(kind) {
 }
 async function isGenexProject(cwd) {
   try {
-    await fs34.access(path37.join(cwd, ".genex"));
+    await fs36.access(path39.join(cwd, ".genex"));
     return true;
   } catch {
     return false;
@@ -24978,25 +25346,25 @@ async function runBudget(opts = {}) {
   const log = createLogger({ quiet: opts.quiet || opts.json });
   const cwd = opts.cwd ?? process.cwd();
   const config = budgetConfig();
-  const fail4 = (message) => {
+  const fail5 = (message) => {
     if (opts.json) writeJson({ command: "budget", status: "failed", error: message });
     else log.error(message);
     process.exitCode = 1;
   };
   const setting = opts.assets !== void 0;
   if (setting && opts.userApproved !== true) {
-    fail4(BUDGET_APPROVAL_REQUIRED);
+    fail5(BUDGET_APPROVAL_REQUIRED);
     return;
   }
   if (setting && (!Number.isInteger(opts.assets) || opts.assets < 0)) {
-    fail4(`--assets takes a whole number of credits, 0 or more (got ${String(opts.assets)}).`);
+    fail5(`--assets takes a whole number of credits, 0 or more (got ${String(opts.assets)}).`);
     return;
   }
   const meta = await readProject(cwd);
   const apiUrl = getApiUrl(opts.apiUrl ?? meta?.apiUrl);
   const token = opts.token ?? await readUserToken(opts.envPath, apiUrl);
   if (!token) {
-    fail4("Not authorized. Run `genex init` first to sign in.");
+    fail5("Not authorized. Run `genex init` first to sign in.");
     return;
   }
   const snapshot = await fetchCreditsSnapshot(apiUrl, token);
@@ -25014,7 +25382,7 @@ async function runBudget(opts = {}) {
     };
     persisted = await writeBudgetStore(cwd, store);
     if (!persisted) {
-      fail4("This folder is not a Genex project (no .genex/), so the allowance has nowhere to live. Run this inside the game folder.");
+      fail5("This folder is not a Genex project (no .genex/), so the allowance has nowhere to live. Run this inside the game folder.");
       return;
     }
   } else if (snapshot && !snapshot.unlimited && !budgetDisabled(config)) {
@@ -25106,39 +25474,39 @@ async function runBudget(opts = {}) {
 }
 
 // src/commands/player.ts
-import fs39 from "fs";
+import fs41 from "fs";
 import fsp2 from "fs/promises";
 import os12 from "os";
-import path43 from "path";
+import path45 from "path";
 import { spawn as spawn8 } from "child_process";
 
 // src/lib/player/paths.ts
 import os8 from "os";
-import path38 from "path";
+import path40 from "path";
 var PLAYER_DRY_RUN_ENV = "GENEX_PLAYER_DRY_RUN";
 function playerDryRun() {
   const raw = process.env[PLAYER_DRY_RUN_ENV];
   return raw === "1" || raw === "true";
 }
 function playerPaths(home = os8.homedir()) {
-  const dir = home === os8.homedir() ? getGenexDir() : path38.join(home, ".genex");
-  const logDir = path38.join(dir, "logs");
+  const dir = home === os8.homedir() ? getGenexDir() : path40.join(home, ".genex");
+  const logDir = path40.join(dir, "logs");
   return {
-    credential: path38.join(dir, "player.json"),
-    state: path38.join(dir, "player-state.json"),
-    relaunch: path38.join(dir, "player-relaunch.json"),
+    credential: path40.join(dir, "player.json"),
+    state: path40.join(dir, "player-state.json"),
+    relaunch: path40.join(dir, "player-relaunch.json"),
     logDir,
-    log: path38.join(logDir, "player.log"),
-    errorLog: path38.join(logDir, "player.error.log")
+    log: path40.join(logDir, "player.log"),
+    errorLog: path40.join(logDir, "player.error.log")
   };
 }
 
 // src/lib/player/store.ts
-import fs35 from "fs/promises";
-import path39 from "path";
+import fs37 from "fs/promises";
+import path41 from "path";
 async function readPlayerInstall(home) {
   try {
-    const raw = await fs35.readFile(playerPaths(home).credential, "utf8");
+    const raw = await fs37.readFile(playerPaths(home).credential, "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed.token !== "string" || typeof parsed.apiUrl !== "string") return null;
     return parsed;
@@ -25168,7 +25536,7 @@ function describeInstall(install2) {
 }
 async function readPlayerState(home) {
   try {
-    return JSON.parse(await fs35.readFile(playerPaths(home).state, "utf8"));
+    return JSON.parse(await fs37.readFile(playerPaths(home).state, "utf8"));
   } catch {
     return null;
   }
@@ -25176,8 +25544,8 @@ async function readPlayerState(home) {
 async function writePlayerState(state, home) {
   const file = playerPaths(home).state;
   try {
-    await fs35.mkdir(path39.dirname(file), { recursive: true, mode: 448 });
-    await fs35.writeFile(file, JSON.stringify(state, null, 2) + "\n", { mode: 384 });
+    await fs37.mkdir(path41.dirname(file), { recursive: true, mode: 448 });
+    await fs37.writeFile(file, JSON.stringify(state, null, 2) + "\n", { mode: 384 });
   } catch {
   }
 }
@@ -25185,8 +25553,8 @@ async function removePlayerFiles(home) {
   const paths = playerPaths(home);
   const removed = [];
   for (const file of [paths.credential, paths.state, paths.relaunch]) {
-    const existed = await fs35.stat(file).then(() => true, () => false);
-    await fs35.rm(file, { force: true }).catch(() => {
+    const existed = await fs37.stat(file).then(() => true, () => false);
+    await fs37.rm(file, { force: true }).catch(() => {
     });
     if (existed) removed.push(file);
   }
@@ -25320,14 +25688,14 @@ var PlayerClient = class {
     this.version = options.version ?? getCliVersion();
     this.timeoutMs = options.timeoutMs ?? 3e4;
   }
-  async call(path44, init2 = {}, provider) {
+  async call(path46, init2 = {}, provider) {
     const headers = {
       Authorization: `Bearer ${this.token}`,
       [PLAYER_VERSION_HEADER]: this.version,
       ...provider ? { [EXTERNAL_PROVIDER_HEADER]: provider } : {},
       ...init2.body === void 0 ? {} : { "Content-Type": "application/json" }
     };
-    const res = await apiFetch(`${this.apiUrl}${path44}`, {
+    const res = await apiFetch(`${this.apiUrl}${path46}`, {
       ...init2,
       headers,
       signal: AbortSignal.timeout(this.timeoutMs)
@@ -25396,10 +25764,10 @@ var PlayerClient = class {
 
 // src/lib/player/runners.ts
 import { spawn as spawn6, spawnSync } from "child_process";
-import fs36 from "fs/promises";
+import fs38 from "fs/promises";
 import fsSync from "fs";
 import os9 from "os";
-import path40 from "path";
+import path42 from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 var WATCHER_RUNNERS = ["claude", "codex"];
 var RUNNER_FOR_FAMILY = { claude: "claude", chatgpt: "codex" };
@@ -25457,7 +25825,7 @@ function resolveOnPath(name, env = process.env, platform = process.platform) {
   const candidates = win ? [`${name}.cmd`, `${name}.exe`, `${name}.bat`, name] : [name];
   for (const dir of dirs) {
     for (const candidate of candidates) {
-      const file = path40.join(dir, candidate);
+      const file = path42.join(dir, candidate);
       try {
         const stat = fsSync.statSync(file);
         if (!stat.isFile()) continue;
@@ -25621,17 +25989,17 @@ async function runJob(job, options = {}) {
   if (!resolved) {
     return { ok: false, release: "runner_unavailable", detail: `missing:${runner}`, durationMs: Date.now() - started };
   }
-  const cwd = path40.join(os9.tmpdir(), `genex-player-${randomUUID3()}`);
-  await fs36.mkdir(cwd, { recursive: true, mode: 448 });
-  const outFile = path40.join(cwd, "result.out");
+  const cwd = path42.join(os9.tmpdir(), `genex-player-${randomUUID3()}`);
+  await fs38.mkdir(cwd, { recursive: true, mode: 448 });
+  const outFile = path42.join(cwd, "result.out");
   let argv;
   if (runner === "claude") {
     argv = claudeArgv(job, policy.claude ?? FALLBACK_POLICY.claude ?? {});
   } else {
     let schemaFile;
     if (job.outputFormat === "json" && job.schema !== void 0) {
-      schemaFile = path40.join(cwd, "schema.json");
-      await fs36.writeFile(schemaFile, JSON.stringify(job.schema), { mode: 384 });
+      schemaFile = path42.join(cwd, "schema.json");
+      await fs38.writeFile(schemaFile, JSON.stringify(job.schema), { mode: 384 });
     }
     argv = codexArgv(job, policy.codex ?? FALLBACK_POLICY.codex ?? {}, { cwd, outFile, ...schemaFile ? { schemaFile } : {} });
   }
@@ -25693,7 +26061,7 @@ async function runJob(job, options = {}) {
       if (!read2.ok) return { ok: false, release: "failed", detail: read2.detail, exitCode: code, durationMs };
       return { ok: true, output: read2.output, exitCode: code, durationMs };
     }
-    const text = await fs36.readFile(outFile, "utf8").catch(() => "");
+    const text = await fs38.readFile(outFile, "utf8").catch(() => "");
     if (code !== 0 && !text.trim()) {
       const classified = classifyFailure(`${stderrText} exit ${code}`);
       return { ok: false, ...classified, detail: `exit_${code}`, exitCode: code, durationMs };
@@ -25702,15 +26070,15 @@ async function runJob(job, options = {}) {
     if (!read.ok) return { ok: false, release: "failed", detail: read.detail, exitCode: code, durationMs };
     return { ok: true, output: read.output, exitCode: code, durationMs };
   } finally {
-    await fs36.rm(cwd, { recursive: true, force: true }).catch(() => {
+    await fs38.rm(cwd, { recursive: true, force: true }).catch(() => {
     });
   }
 }
 
 // src/lib/player/service.ts
-import fs37 from "fs/promises";
+import fs39 from "fs/promises";
 import os10 from "os";
-import path41 from "path";
+import path43 from "path";
 import { execFile } from "child_process";
 import { promisify } from "util";
 var run2 = promisify(execFile);
@@ -25727,9 +26095,9 @@ function servicePlatform(platform = process.platform) {
 }
 function servicePaths(platform, home = os10.homedir()) {
   const { log, errorLog } = playerPaths(home);
-  if (platform === "darwin") return { log, errorLog, unit: path41.join(home, "Library", "LaunchAgents", `${SERVICE_LABEL}.plist`) };
-  if (platform === "linux") return { log, errorLog, unit: path41.join(home, ".config", "systemd", "user", SYSTEMD_UNIT) };
-  return { log, errorLog, unit: path41.join(home, "AppData", "Roaming", "Microsoft", "Windows", "Start Menu", "Programs", "Startup", "genex-player.cmd") };
+  if (platform === "darwin") return { log, errorLog, unit: path43.join(home, "Library", "LaunchAgents", `${SERVICE_LABEL}.plist`) };
+  if (platform === "linux") return { log, errorLog, unit: path43.join(home, ".config", "systemd", "user", SYSTEMD_UNIT) };
+  return { log, errorLog, unit: path43.join(home, "AppData", "Roaming", "Microsoft", "Windows", "Start Menu", "Programs", "Startup", "genex-player.cmd") };
 }
 function xmlEscape(value) {
   return value.replace(/[<>&'"]/g, (ch) => ({ "<": "&lt;", ">": "&gt;", "&": "&amp;", "'": "&apos;", '"': "&quot;" })[ch]);
@@ -25808,9 +26176,9 @@ function autostartCommand(opts) {
 }
 async function installService(input, platform = servicePlatform()) {
   const paths = servicePaths(platform, input.home);
-  await fs37.mkdir(path41.dirname(paths.unit), { recursive: true });
-  await fs37.mkdir(path41.dirname(paths.log), { recursive: true, mode: 448 });
-  await fs37.writeFile(paths.unit, unitFile(platform, input, paths), { mode: platform === "win32" ? 420 : 384 });
+  await fs39.mkdir(path43.dirname(paths.unit), { recursive: true });
+  await fs39.mkdir(path43.dirname(paths.log), { recursive: true, mode: 448 });
+  await fs39.writeFile(paths.unit, unitFile(platform, input, paths), { mode: platform === "win32" ? 420 : 384 });
   if (playerDryRun()) return { unit: paths.unit, loaded: false, detail: "dry run \u2014 the unit was written, the system was not asked" };
   if (platform === "darwin") {
     const domain = `gui/${process.getuid?.() ?? 501}`;
@@ -25839,7 +26207,7 @@ async function installService(input, platform = servicePlatform()) {
 }
 async function serviceInstalled(home = os10.homedir(), platform = servicePlatform()) {
   const paths = servicePaths(platform, home);
-  return await fs37.stat(paths.unit).then(() => paths.unit, () => null);
+  return await fs39.stat(paths.unit).then(() => paths.unit, () => null);
 }
 async function stopService(home = os10.homedir(), platform = servicePlatform()) {
   const paths = servicePaths(platform, home);
@@ -25869,15 +26237,15 @@ async function uninstallService(home = os10.homedir(), platform = servicePlatfor
       });
     }
   }
-  await fs37.rm(paths.unit, { force: true }).catch(() => {
+  await fs39.rm(paths.unit, { force: true }).catch(() => {
   });
   return { unit: paths.unit, loaded: false, detail: present ? "removed" : "nothing installed" };
 }
 
 // src/lib/player/relaunch.ts
-import fs38 from "fs/promises";
+import fs40 from "fs/promises";
 import fsSync2 from "fs";
-import path42 from "path";
+import path44 from "path";
 import { spawn as spawn7 } from "child_process";
 var RELAUNCH_COOLDOWN_MS = 10 * 60 * 1e3;
 function relaunchPlan(input) {
@@ -25905,7 +26273,7 @@ function relaunchPossible() {
 }
 async function relaunchOnCooldown(home, now = Date.now()) {
   try {
-    const raw = await fs38.readFile(playerPaths(home).relaunch, "utf8");
+    const raw = await fs40.readFile(playerPaths(home).relaunch, "utf8");
     const at = Date.parse(JSON.parse(raw).at ?? "");
     return Number.isFinite(at) && now - at < RELAUNCH_COOLDOWN_MS;
   } catch {
@@ -25915,8 +26283,8 @@ async function relaunchOnCooldown(home, now = Date.now()) {
 async function markRelaunch(version, home) {
   const file = playerPaths(home).relaunch;
   try {
-    await fs38.mkdir(path42.dirname(file), { recursive: true, mode: 448 });
-    await fs38.writeFile(file, JSON.stringify({ at: (/* @__PURE__ */ new Date()).toISOString(), version }) + "\n", { mode: 384 });
+    await fs40.mkdir(path44.dirname(file), { recursive: true, mode: 448 });
+    await fs40.writeFile(file, JSON.stringify({ at: (/* @__PURE__ */ new Date()).toISOString(), version }) + "\n", { mode: 384 });
   } catch {
   }
 }
@@ -25940,7 +26308,7 @@ async function relaunchWatcher(input) {
   let err;
   const paths = playerPaths(input.home);
   try {
-    await fs38.mkdir(paths.logDir, { recursive: true, mode: 448 });
+    await fs40.mkdir(paths.logDir, { recursive: true, mode: 448 });
     out = fsSync2.openSync(paths.log, "a", 384);
     err = fsSync2.openSync(paths.errorLog, "a", 384);
   } catch {
@@ -26286,7 +26654,7 @@ async function runPlayer(opts = {}) {
   const log = createLogger({ quiet: opts.quiet || opts.json });
   const sub = opts.name?.trim() || "status";
   if (!SUBS4.includes(sub)) {
-    fail3(opts, log, `player ${sub}`, `Unknown subcommand ${sub}. Use: ${SUBS4.join(", ")}.`);
+    fail4(opts, log, `player ${sub}`, `Unknown subcommand ${sub}. Use: ${SUBS4.join(", ")}.`);
     return;
   }
   if (opts.dryRun) process.env[PLAYER_DRY_RUN_ENV] = "1";
@@ -26307,7 +26675,7 @@ async function install(opts, log) {
       ...opts.timeoutSec ? { waitMs: opts.timeoutSec * 1e3 } : {}
     });
   } catch (error) {
-    fail3(opts, log, "player install", error instanceof Error ? error.message : String(error));
+    fail4(opts, log, "player install", error instanceof Error ? error.message : String(error));
     return;
   }
   let record = {
@@ -26344,13 +26712,13 @@ async function install(opts, log) {
       log.warn(`This Genex needs player watcher ${error.minVersion} or newer; ${error.latestVersion} is current.`);
       if (!outcome2.launched) {
         log.plain(`  ${c.cyan("\u2192")} Update and re-run: ${c.cyan(`npx -y @genex-ai/cli-demo@${error.latestVersion} player install`)}`);
-        fail3(opts, log, "player install", "player_update_required", { minVersion: error.minVersion, latestVersion: error.latestVersion });
+        fail4(opts, log, "player install", "player_update_required", { minVersion: error.minVersion, latestVersion: error.latestVersion });
         return;
       }
       log.plain(`  ${c.cyan("\u2192")} Picked up by ${c.cyan(`@genex-ai/cli-demo@${error.latestVersion}`)} \u2014 it finishes the install.`);
       return;
     }
-    fail3(opts, log, "player install", error instanceof PlayerAuthError ? "Genex refused the approval this machine just collected. Re-run `genex player install`." : `Couldn't reach Genex to register this machine (${error instanceof Error ? error.message : String(error)}).`);
+    fail4(opts, log, "player install", error instanceof PlayerAuthError ? "Genex refused the approval this machine just collected. Re-run `genex player install`." : `Couldn't reach Genex to register this machine (${error instanceof Error ? error.message : String(error)}).`);
     return;
   }
   const platform = servicePlatform();
@@ -26421,8 +26789,8 @@ async function spawnDetachedRun(apiUrl, opts) {
   try {
     const paths = playerPaths();
     await fsp2.mkdir(paths.logDir, { recursive: true, mode: 448 });
-    out = fs39.openSync(paths.log, "a", 384);
-    err = fs39.openSync(paths.errorLog, "a", 384);
+    out = fs41.openSync(paths.log, "a", 384);
+    err = fs41.openSync(paths.errorLog, "a", 384);
     const args = [process.argv[1] ?? "", "player", "run", ...opts.apiUrl ? ["--api-url", apiUrl] : []];
     const child = spawn8(process.execPath, args, { detached: true, stdio: ["ignore", out, err] });
     child.on("error", () => {
@@ -26433,7 +26801,7 @@ async function spawnDetachedRun(apiUrl, opts) {
     return false;
   } finally {
     for (const fd of [out, err]) if (fd !== void 0) try {
-      fs39.closeSync(fd);
+      fs41.closeSync(fd);
     } catch {
     }
   }
@@ -26444,11 +26812,11 @@ function usesNonDefaultStand(opts, apiUrl) {
 async function run3(opts, log) {
   const record = await readPlayerInstall();
   if (!record) {
-    fail3(opts, log, "player run", PLAYER_NOT_INSTALLED);
+    fail4(opts, log, "player run", PLAYER_NOT_INSTALLED);
     return;
   }
   if (installExpired(record)) {
-    fail3(opts, log, "player run", `This machine's Genex approval expired on ${record.expiresAt} \u2014 run \`genex player install\` again.`);
+    fail4(opts, log, "player run", `This machine's Genex approval expired on ${record.expiresAt} \u2014 run \`genex player install\` again.`);
     return;
   }
   const apiUrl = opts.apiUrl ? normalizeApiOrigin(getApiUrl(opts.apiUrl)) : record.apiUrl;
@@ -26632,14 +27000,14 @@ async function uninstall(opts, log) {
     writeJsonLine2({ command: "player uninstall", status: "ok", error: null, unit: service.unit, detail: service.detail, removed });
     return;
   }
-  log.success(`Removed: ${service.detail} (${path43.basename(service.unit)})`);
+  log.success(`Removed: ${service.detail} (${path45.basename(service.unit)})`);
   for (const file of removed) log.dim(`  deleted ${file}`);
   if (removed.length === 0) log.dim("  no credential was stored here");
   log.plain("");
   log.plain("  This machine can no longer answer in-game requests. The approval itself can also be");
   log.plain("  revoked from your Genex dashboard, which ends it everywhere at once.");
 }
-function fail3(opts, log, command, message, extra = {}) {
+function fail4(opts, log, command, message, extra = {}) {
   if (opts.json) writeJsonLine2({ command, status: "failed", error: message, ...extra });
   else log.error(message);
   process.exitCode = 1;
@@ -26768,6 +27136,14 @@ ${c.bold("Usage")}
   genex rollback [--yes]             Put players back on the previous version. One
                                      version back, instantly \u2014 your code is not
                                      changed, only what the play URL serves.
+  genex cover [<file>]               Show this game's cover and where it came from, or
+                                     make <file> (PNG/JPEG/WebP, \u22648 MB) the cover: one
+                                     real frame of the game \u2014 its signature moment,
+                                     real gameplay, well lit, no menus or popups,
+                                     landscape 16:9, no text. A cover the owner chose
+                                     on the dashboard is never replaced from here.
+                                     'genex preview' also uploads a new
+                                     .genex/scratch/cover.png by itself.
   genex make-remixable [options]     Make THIS game remixable by everyone \u2014 migrates a
                                      private source onto a public managed genex repo.
   genex domain <sub> [host]          Play this game on a domain you own:
@@ -27067,7 +27443,10 @@ ${c.bold("Options for `preview` / `publish`")}
   --description <text> (publish) Gallery description.
   --categories <list>  (publish) 1-3 gallery categories, comma-separated.
                        Valid: games, assets, physics, terrain, lighting, vfx.
-  --regenerate-cover   (publish) Re-mint the disc cover (concept changed).
+  --regenerate-cover   (publish) Ask for a new AI cover. Only on stands with AI
+                       covers switched on (otherwise ignored), and it never
+                       replaces a cover the owner or 'genex cover' set \u2014 for a
+                       real frame of the game, use 'genex cover <file>'.
   --source-repo-url <url>  (publish) Upstream repo this game is a port of \u2014
                        shown as "Ported from \u2026" credit on the game page.
   --source-author <name>   (publish) Upstream author to credit.
@@ -27084,6 +27463,13 @@ ${c.bold("Options for `list`")}
   --env <path>         Token env file (default: ~/.genex/env).
   --auth-url <url>     Override the auth site (used only if sign-in is needed).
 
+${c.bold("Options for `cover`")}
+  <file>               The image to make the cover (positional). Omit it to see
+                       the current cover and where it came from.
+  --json               One machine-readable result object.
+  --api-url <url>      Override the API base URL.
+  --env <path>         Token env file (default: ~/.genex/env).
+
 ${c.bold("Options for `character` / `animations search`")}
   --image <path|url>   Build from supplied PNG/JPEG references; repeat up to 4 times.
                        One view per image, same character; local files total \u22644 MB,
@@ -27147,6 +27533,8 @@ ${c.bold("Examples")}
   genex preview
   genex publish
   genex publish --categories games,vfx
+  genex cover
+  genex cover .genex/scratch/cover.png
   genex make-remixable
   genex domain add play.mygame.com
   genex domain list
@@ -28601,6 +28989,9 @@ async function main() {
       case "rollback":
         await runRollback(parsed.options);
         break;
+      case "cover":
+        await runCover({ ...parsed.options, imagePath: parsed.options.name });
+        break;
       case "publish":
         await runPublish(parsed.options);
         break;