@genex-ai/cli-demo 1.34.9 → 1.35.0-dev.737

package/dist/index.js

@@ -42,7 +42,7 @@ import {
   writeSecretFile,
   writeUserToken,
   writeWorkspace
-} from "./chunk-5WBSWMH5.js";
+} from "./chunk-FYHYZYBC.js";
 import {
   CLI_CHANNEL,
   DEFAULT_API_URL,
@@ -63,7 +63,7 @@ import {
   normalizeApiOrigin,
   originKey,
   resolveAgentTargets
-} from "./chunk-QI7FIYBY.js";
+} from "./chunk-K4EHXOZK.js";
 
 // src/instrument.ts
 import * as Sentry from "@sentry/node";
@@ -418,7 +418,7 @@ async function authorizeLoopback(authBaseUrl, options) {
       cleanup();
       resolve(token);
     };
-    const fail3 = (err) => {
+    const fail4 = (err) => {
       if (settled) return;
       settled = true;
       cleanup();
@@ -435,7 +435,7 @@ async function authorizeLoopback(authBaseUrl, options) {
         }
       });
     });
-    server.on("error", (err) => fail3(err));
+    server.on("error", (err) => fail4(err));
     server.listen(0, "127.0.0.1", () => {
       const { port } = server.address();
       const redirectUri = `http://127.0.0.1:${port}/callback`;
@@ -466,7 +466,7 @@ async function authorizeLoopback(authBaseUrl, options) {
         );
       }
       timer = setTimeout(() => {
-        fail3(
+        fail4(
           new Error(
             "Timed out waiting for authorization. Re-run the command to try again."
           )
@@ -569,6 +569,7 @@ function openBrowser(url, onError = () => {
 }) {
   let command;
   let args;
+  if (process.env.GENEX_NO_BROWSER === "1") return false;
   const custom = (process.env.GENEX_BROWSER || process.env.BROWSER)?.trim();
   const customParts = custom ? tokenizeCommand(custom) : [];
   if (customParts.length > 0) {
@@ -901,6 +902,7 @@ Important note: put soul into your creations, with many details and love. Aim to
 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).
+24. **Benchmark before declaring an in-game LLM price.** 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, and \`estimateCoins\` is the FIXED price of a started attempt: charged whether it succeeds, fails, is canceled, or stops at its own budget. Never pick that number by judgement or from a vendor's rate card. Run the real prompt on your own coins \u2014 \`npx genex llm bench "<the prompt>" --schema <file> --samples 3 --max-coins <n> --user-approved\` \u2014 and declare the figure it recommends, recorded in \`DESIGN.md\` with its model and date; re-benchmark whenever the prompt, the schema or the model changes, because a prompt edit is a price change. 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 is computed from the game's own loop. Model output is data the game validates against its own expectation \u2014 never executed, and never authority over coin, items, entitlements or rewards. Load \`$genex-llm-in-games\` before writing any of it.
 ${CONTRACT_END}
 `;
 var TOOLS_CONTRACT_HEAD = `# Genex Tools (always in effect in this folder)
@@ -914,12 +916,18 @@ var TOOLS_CONTRACT_OFFER = `5. **When the game is built and playable \u2014 neve
 var TOOLS_CONTRACT_HOSTED_LAWS = `5. **This game is hosted on Genex now, and publishing is glue \u2014 never a rebuild.** The game ships exactly as the user built it: \`initEmbed()\` first in the boot code (the \`genex-threejs-embed-auth\` card has the call; the renderer draws before any \`await waitForPlayer()\`), a static build into \`dist/\` with relative asset paths, then \`npx genex preview\`. Never restructure, reformat or "improve" the game to ship it, never scaffold a new app around it, and never start a design document or a build plan for it \u2014 the user's own process is theirs. Load the \`genex-tool-publish\` card before the first preview; it owns the vocabulary, the links and the limits.
 6. **Ship first, then report.** \`preview\` prints a preflight \u2014 phone memory, a missing volume slider, an asset nobody wired, a viewport line. It never blocks a deploy, so push the build as it is, hand over the link, THEN relay each preflight line to the user in one plain sentence with an offer to fix it, and fix one only on their yes. The preflight is a report for the user, not a to-do list for you.
 7. **The link is the game's page, and there are two versions.** After every preview give the user \`<dashboard>/draft/<slug>\` \u2014 \`dashboardOrigins[0]\` and \`slug\` from \`.genex/project.json\` \u2014 never localhost, a file path or the bare play origin. \`preview\` updates the draft and never touches what players are on; the first release is \`npx genex publish\` (it lists the game); after that "publish it", "update it" and "yes" all mean \`npx genex promote\` \u2014 the exact draft build, no rebuild. Ask once per round of work, in one line, and keep working while you wait.`;
+var TOOLS_CONTRACT_LLM_OFFER = `A model running while people play is built into the Genex platform \u2014 the player pays, with Genex coins or their own Claude/ChatGPT subscription, and approves it on a Genex sheet; your game just calls \`generate()\`. Want it that way?`;
+function toolsContractLlmLaw(n, hosted) {
+  const onYes = hosted ? "On a yes, load `$genex-tool-llm` and then `$genex-llm-in-games`, which owns the build." : "On a yes, load `$genex-tool-llm`, which owns the rest: it checks the lane with `npx genex llm models` first, then runs `npx genex init --convert` (a hosted game is a static browser build \u2014 a local server holding a key can never ship).";
+  return `${n}. **A model running while people PLAY is a platform feature \u2014 never something you wire onto the user's own meter.** When a request implies one (NPCs that talk or decide in their own words, content written from what the player types, a prompt box in the game, "let the player pick a model"), recognise it, say in ONE line: "${TOOLS_CONTRACT_LLM_OFFER}" \u2014 then ASK and wait. ${onYes} On a no, build the authored version instead. Either way, never ship a game that calls a model on a key or an account of the user's own: every visitor would spend their money with nobody approving it, and the credential is readable in the bundle. Player-funded generation is text and JSON only \u2014 3D, images, video and audio stay the asset lanes above, on the user's meter.`;
+}
 function toolsContractBlock(opts) {
   return `${CONTRACT_BEGIN}
 ${TOOLS_CONTRACT_HEAD}${opts.hosted ? " This game is also hosted on Genex: `preview` \xB7 `promote` \xB7 `publish` \xB7 `rollback` \xB7 `rename` work here (the `genex-tool-publish` card owns them)." : ""}
 
 ${TOOLS_CONTRACT_LAWS_1_TO_4}
 ${opts.hosted ? TOOLS_CONTRACT_HOSTED_LAWS : TOOLS_CONTRACT_OFFER}
+${toolsContractLlmLaw(opts.hosted ? 8 : 6, opts.hosted)}
 ${CONTRACT_END}
 `;
 }
@@ -1001,7 +1009,7 @@ async function writeToolsContract(projectDir, opts = {}) {
 }
 async function healAncestorContracts(projectDir, stopDir = os3.homedir()) {
   const findings = [];
-  const stop = path5.resolve(stopDir);
+  const stop2 = path5.resolve(stopDir);
   let dir = path5.dirname(path5.resolve(projectDir));
   for (let depth = 0; depth < 20; depth++) {
     try {
@@ -1043,7 +1051,7 @@ async function healAncestorContracts(projectDir, stopDir = os3.homedir()) {
       }
     } catch {
     }
-    if (dir === stop) break;
+    if (dir === stop2) break;
     const parent = path5.dirname(dir);
     if (parent === dir) break;
     dir = parent;
@@ -1225,13 +1233,18 @@ async function hasGenexSkills(skillsDir) {
   }
 }
 var TOOL_SKILL_PREFIX = "genex-tool-";
-var HOSTED_TOOL_SKILLS = ["genex-tool-publish", "genex-threejs-embed-auth"];
+var HOSTED_TOOL_SKILLS = [
+  "genex-tool-publish",
+  "genex-threejs-embed-auth",
+  "genex-llm-in-games"
+];
 var REMIX_EXCLUDED_SKILLS = [
   "genex-game-director",
   "genex-getting-started",
   "genex-tool-audio",
   "genex-tool-character",
   "genex-tool-image",
+  "genex-tool-llm",
   "genex-tool-model",
   "genex-tool-publish",
   "genex-tool-texture",
@@ -1485,8 +1498,8 @@ async function installedPackageVersion(cwd, name) {
     return null;
   }
 }
-function formatNudge(label, latest, installed, install) {
-  return `\u2B06 Genex ${label} ${latest} available (installed ${installed}) \u2014 run: ${install}`;
+function formatNudge(label, latest, installed, install2) {
+  return `\u2B06 Genex ${label} ${latest} available (installed ${installed}) \u2014 run: ${install2}`;
 }
 async function reportUpdateNudges(check, log, cwd = process.cwd(), cachePath = getUpdateCachePath()) {
   try {
@@ -1704,8 +1717,8 @@ async function ensureLocalCli(log, cwd = process.cwd(), opts = {}) {
   const spec = `${CLI_PACKAGE}@${CLI_CHANNEL}`;
   const { command, args } = installArgs(pm, spec);
   log.step(`Adding ${c.cyan(CLI_PACKAGE)} as a devDependency (${pm}) so npx genex resolves here\u2026`);
-  const run2 = opts.runner ?? spawnInstall;
-  const result = await run2(command, args, cwd);
+  const run4 = opts.runner ?? spawnInstall;
+  const result = await run4(command, args, cwd);
   if (result.ok) {
     log.success(`${c.cyan("npx genex")} now resolves in this folder.`);
   } else {
@@ -1746,10 +1759,10 @@ function sourceCrc32(bytes, previous = 0) {
 var RemixError = class extends Error {
   code;
   status;
-  constructor(code, message, status) {
+  constructor(code, message, status2) {
     super(message);
     this.code = code;
-    this.status = status;
+    this.status = status2;
   }
 };
 var badArchive = (message) => {
@@ -1926,8 +1939,8 @@ function draftPageUrl(dashboard, slug) {
 function publicPageUrl(dashboard, slug) {
   return `${dashboard.replace(/\/+$/, "")}/${slug}`;
 }
-function gamePageUrl(dashboard, slug, status) {
-  return status === "published" ? publicPageUrl(dashboard, slug) : draftPageUrl(dashboard, slug);
+function gamePageUrl(dashboard, slug, status2) {
+  return status2 === "published" ? publicPageUrl(dashboard, slug) : draftPageUrl(dashboard, slug);
 }
 
 // src/lib/deploy.ts
@@ -2005,10 +2018,10 @@ async function readLedger(cwd = process.cwd()) {
   }
   return [...entries.values()];
 }
-async function recordTerminal(id, status, urls, cwd = process.cwd()) {
+async function recordTerminal(id, status2, urls, cwd = process.cwd()) {
   const existing = (await readLedger(cwd)).find((e) => e.id === id);
-  if (existing && existing.status === status) return;
-  await append(cwd, { t: "done", id, status, ...urls?.length ? { urls } : {} });
+  if (existing && existing.status === status2) return;
+  await append(cwd, { t: "done", id, status: status2, ...urls?.length ? { urls } : {} });
 }
 async function recordShipped(commit, cwd = process.cwd()) {
   await append(cwd, { t: "ship", at: (/* @__PURE__ */ new Date()).toISOString(), ...commit ? { commit } : {} });
@@ -2035,13 +2048,13 @@ async function countFailed(kind, cwd = process.cwd()) {
 }
 async function trailingFailures(kind, cwd = process.cwd()) {
   const rows = (await readLedger(cwd)).filter((e) => e.kind === kind);
-  let run2 = 0;
+  let run4 = 0;
   for (let i = rows.length - 1; i >= 0; i -= 1) {
-    const status = rows[i].status;
-    if (status === "completed") break;
-    if (status === "failed") run2 += 1;
+    const status2 = rows[i].status;
+    if (status2 === "completed") break;
+    if (status2 === "failed") run4 += 1;
   }
-  return run2;
+  return run4;
 }
 async function countOutcomes(kind, cwd = process.cwd()) {
   const rows = (await readLedger(cwd)).filter((e) => e.kind === kind);
@@ -2578,25 +2591,25 @@ function embedBootNudges(log, d) {
   }
 }
 function generationNudges(log, g) {
-  const describe = (refs) => refs.map((r) => `${r.kind} ${r.id} ("${r.prompt.slice(0, 48)}")`).join("; ");
+  const describe2 = (refs) => refs.map((r) => `${r.kind} ${r.id} ("${r.prompt.slice(0, 48)}")`).join("; ");
   if (g.unpicked.length) {
     log.warn(
-      `${g.unpicked.length} generation(s) enqueued 15+ minutes ago were never picked up: ${describe(g.unpicked)}. Run npx genex wait <id> on each (npx genex wait --all shows every status at once) \u2014 landed assets get wired in before the last push of a session, never parked for "later".`
+      `${g.unpicked.length} generation(s) enqueued 15+ minutes ago were never picked up: ${describe2(g.unpicked)}. Run npx genex wait <id> on each (npx genex wait --all shows every status at once) \u2014 landed assets get wired in before the last push of a session, never parked for "later".`
     );
   }
   if (g.unresolved.length) {
     log.warn(
-      `${g.unresolved.length} generation(s) are wired into the game but were never picked up, so their real status is unknown: ${describe(g.unresolved)}. A generation that failed server-side (credits, moderation) leaves a dead URL \u2014 the asset just silently never appears. One call checks them all: npx genex wait --all.`
+      `${g.unresolved.length} generation(s) are wired into the game but were never picked up, so their real status is unknown: ${describe2(g.unresolved)}. A generation that failed server-side (credits, moderation) leaves a dead URL \u2014 the asset just silently never appears. One call checks them all: npx genex wait --all.`
     );
   }
   if (g.deadWired.length) {
     log.warn(
-      `${g.deadWired.length} FAILED generation(s) are still wired into the game: ${describe(g.deadWired)}. Those URLs will never exist \u2014 each asset silently never appears. Replace the wiring or re-generate (that bills a new one), and tell the user what changed.`
+      `${g.deadWired.length} FAILED generation(s) are still wired into the game: ${describe2(g.deadWired)}. Those URLs will never exist \u2014 each asset silently never appears. Replace the wiring or re-generate (that bills a new one), and tell the user what changed.`
     );
   }
   if (g.unwired.length) {
     log.warn(
-      `${g.unwired.length} finished generation(s) are wired nowhere in the game: ${describe(g.unwired)}. Each was paid for \u2014 wire it in (its URL embeds the id) or tell the user in one plain line why it stays unused.`
+      `${g.unwired.length} finished generation(s) are wired nowhere in the game: ${describe2(g.unwired)}. Each was paid for \u2014 wire it in (its URL embeds the id) or tell the user in one plain line why it stays unused.`
     );
   }
   if (g.musicNoSlider) {
@@ -2760,14 +2773,14 @@ function classify(cells) {
   const name = cells[0] ?? "";
   if (/^<.*>$/.test(name)) return null;
   const rest = cells.slice(1).join(" ");
-  const status = (STATUS.exec(rest) ?? [""])[0].toLowerCase();
-  if (PROCEDURAL_ROW.test(rest)) return { name, detail: rest, lane: null, status, procedural: true };
+  const status2 = (STATUS.exec(rest) ?? [""])[0].toLowerCase();
+  if (PROCEDURAL_ROW.test(rest)) return { name, detail: rest, lane: null, status: status2, procedural: true };
   const token = new RegExp(LANE_TOKEN.source).exec(rest)?.[1];
   const fromSkill = token ? LANE_OF_SKILL[token] : void 0;
-  if (fromSkill) return { name, detail: rest, lane: fromSkill, status, procedural: false };
+  if (fromSkill) return { name, detail: rest, lane: fromSkill, status: status2, procedural: false };
   if (!PAID_ROW.test(rest) && !/https?:\/\//.test(rest) && !/generating\s*\(/i.test(rest)) return null;
   const lane = LANE_WORDS.find(([re]) => re.test(rest))?.[1] ?? null;
-  return { name, detail: rest, lane, status, procedural: false };
+  return { name, detail: rest, lane, status: status2, procedural: false };
 }
 function auditGenerationPlan(input) {
   const { design, ledger } = input;
@@ -2836,8 +2849,8 @@ function auditGenerationPlan(input) {
     if (lanesRun.has(lane) || lanesPending.has(lane) || owed.has(lane) || lane === "skybox") continue;
     if (!rows.some((r) => r.lane === lane)) owed.set(lane, ["declared as this subsystem's lane"]);
   }
-  for (const [lane, names] of owed) {
-    const shown = names.slice(0, 3).join(", ") + (names.length > 3 ? `, +${names.length - 3} more` : "");
+  for (const [lane, names2] of owed) {
+    const shown = names2.slice(0, 3).join(", ") + (names2.length > 3 ? `, +${names2.length - 3} more` : "");
     warnings.push(
       `DESIGN.md plans generated ${lane} work (${shown}) and this project has no ${lane} generation that landed \u2014 the plan says so and the generation ledger has nothing completed. Generate it (${LANE_COMMAND[lane] ?? `npx genex ${lane}`} "<prompt>" --no-wait), or change the row to say what happens instead and why.`
     );
@@ -3487,8 +3500,8 @@ function requireOpt(value, flag, sub) {
 async function uiExtract(opts, log) {
   const input = requireOpt(opts.input, "--in", "extract");
   const outDir = requireOpt(opts.outDir, "--out-dir", "extract");
-  const names = (opts.names ?? "").split(",").map((s) => s.trim()).filter(Boolean);
-  if (names.length === 0) fail("Missing --names (comma-separated element names, reading order).");
+  const names2 = (opts.names ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+  if (names2.length === 0) fail("Missing --names (comma-separated element names, reading order).");
   const minPixels = opts.minPixels ?? 2e3;
   const padding = opts.padding ?? 8;
   const chroma = opts.chroma ?? 240;
@@ -3497,7 +3510,7 @@ async function uiExtract(opts, log) {
   const { width: W, height: H, data } = sheet;
   await fs16.mkdir(outDir, { recursive: true });
   log.plain(c.bold("genex ui extract"));
-  log.dim(`  ${input} (${W}x${H}) \u2192 ${outDir}, ${names.length} names`);
+  log.dim(`  ${input} (${W}x${H}) \u2192 ${outDir}, ${names2.length} names`);
   let hasTransparency = false;
   for (let i = 0; i < W * H; i++) {
     if (data[i * 4 + 3] < 250) {
@@ -3533,32 +3546,32 @@ async function uiExtract(opts, log) {
   if (dilatePx > 0) {
     const tmp = new Uint8Array(W * H);
     for (let y = 0; y < H; y++) {
-      let run2 = 0;
+      let run4 = 0;
       for (let x = 0; x < W; x++) {
-        if (subject[y * W + x]) run2 = dilatePx;
-        else if (run2 > 0) run2--;
-        tmp[y * W + x] = run2 > 0 || subject[y * W + x] ? 1 : 0;
+        if (subject[y * W + x]) run4 = dilatePx;
+        else if (run4 > 0) run4--;
+        tmp[y * W + x] = run4 > 0 || subject[y * W + x] ? 1 : 0;
       }
-      run2 = 0;
+      run4 = 0;
       for (let x = W - 1; x >= 0; x--) {
-        if (subject[y * W + x]) run2 = dilatePx;
-        else if (run2 > 0) run2--;
-        if (run2 > 0) tmp[y * W + x] = 1;
+        if (subject[y * W + x]) run4 = dilatePx;
+        else if (run4 > 0) run4--;
+        if (run4 > 0) tmp[y * W + x] = 1;
       }
     }
     const tmp2 = new Uint8Array(W * H);
     for (let x = 0; x < W; x++) {
-      let run2 = 0;
+      let run4 = 0;
       for (let y = 0; y < H; y++) {
-        if (tmp[y * W + x]) run2 = dilatePx;
-        else if (run2 > 0) run2--;
-        tmp2[y * W + x] = run2 > 0 || tmp[y * W + x] ? 1 : 0;
+        if (tmp[y * W + x]) run4 = dilatePx;
+        else if (run4 > 0) run4--;
+        tmp2[y * W + x] = run4 > 0 || tmp[y * W + x] ? 1 : 0;
       }
-      run2 = 0;
+      run4 = 0;
       for (let y = H - 1; y >= 0; y--) {
-        if (tmp[y * W + x]) run2 = dilatePx;
-        else if (run2 > 0) run2--;
-        if (run2 > 0) tmp2[y * W + x] = 1;
+        if (tmp[y * W + x]) run4 = dilatePx;
+        else if (run4 > 0) run4--;
+        if (run4 > 0) tmp2[y * W + x] = 1;
       }
     }
     connect = tmp2;
@@ -3604,9 +3617,9 @@ async function uiExtract(opts, log) {
       }
     );
   }
-  if (big.length < names.length) {
+  if (big.length < names2.length) {
     log.warn(
-      `Only ${big.length} components \u2265 ${minPixels}px; expected ${names.length}. Lower --min-pixels or check the sheet.`
+      `Only ${big.length} components \u2265 ${minPixels}px; expected ${names2.length}. Lower --min-pixels or check the sheet.`
     );
   }
   for (const comp of big) {
@@ -3648,7 +3661,7 @@ async function uiExtract(opts, log) {
     band.items.sort((a, b) => a.cx - b.cx);
     sorted.push(...band.items);
   }
-  const nameOf = (i) => i < names.length ? names[i] : `extra-${i - names.length}`;
+  const nameOf = (i) => i < names2.length ? names2[i] : `extra-${i - names2.length}`;
   for (let i = 0; i < sorted.length; i++) {
     const comp = sorted[i];
     const x0 = Math.max(0, comp.minX - padding);
@@ -3678,7 +3691,7 @@ async function uiExtract(opts, log) {
   const extractions = [];
   for (let i = 0; i < sorted.length; i++) {
     const comp = sorted[i];
-    const name = i < names.length ? names[i] : `extra-${i - names.length}`;
+    const name = i < names2.length ? names2[i] : `extra-${i - names2.length}`;
     const padX0 = Math.max(0, comp.minX - padding);
     const padY0 = Math.max(0, comp.minY - padding);
     const padX1 = Math.min(W, comp.maxX + padding + 1);
@@ -3775,7 +3788,7 @@ async function uiExtract(opts, log) {
       2
     )
   );
-  const missing = names.filter((n) => !extractions.some((e) => e.name === n));
+  const missing = names2.filter((n) => !extractions.some((e) => e.name === n));
   log.plain("");
   log.success(`Extracted ${extractions.length} elements \u2192 ${outDir} (+ .bbox.json sidecars).`);
   if (missing.length > 0) {
@@ -4105,13 +4118,13 @@ function autoDetectPairs(image, opts, log) {
     lastCy = cell.cy;
   }
   annotatedCells.sort((a, b) => bandOf.get(a) - bandOf.get(b) || a.cx - b.cx);
-  const names = (opts.names ?? "").split(",").map((s) => s.trim()).filter(Boolean);
-  if (names.length > 0 && names.length !== annotatedCells.length) {
+  const names2 = (opts.names ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+  if (names2.length > 0 && names2.length !== annotatedCells.length) {
     fail(
-      `--names has ${names.length} name(s) but --auto detected ${annotatedCells.length} annotated cell(s). Match the counts (reading order) or drop --names for meter-1..n.`
+      `--names has ${names2.length} name(s) but --auto detected ${annotatedCells.length} annotated cell(s). Match the counts (reading order) or drop --names for meter-1..n.`
     );
   }
-  for (const name of names) {
+  for (const name of names2) {
     if (!/^[a-z0-9][a-z0-9-]*$/i.test(name)) fail("Invalid pair name.", { name });
   }
   const scoreTwin = (a, c2) => {
@@ -4187,7 +4200,7 @@ function autoDetectPairs(image, opts, log) {
       h: boxH
     });
     out.push({
-      name: names[i] ?? `meter-${i + 1}`,
+      name: names2[i] ?? `meter-${i + 1}`,
       cleanBox: place(best.cell.minX, best.cell.minY, cw, ch),
       annotatedBox: place(ann.minX, ann.minY, aw, ah),
       // D6: --auto used to leave the component count ungated (null). --expect N
@@ -5688,9 +5701,9 @@ import crypto3 from "crypto";
 async function createDraftProject(opts) {
   const { apiUrl, token, dashboardUrl, log } = opts;
   log.step("Creating your project\u2026");
-  const names = [opts.name, `${opts.name}-${randomSuffix()}`];
-  for (let i = 0; i < names.length; i++) {
-    const name = names[i];
+  const names2 = [opts.name, `${opts.name}-${randomSuffix()}`];
+  for (let i = 0; i < names2.length; i++) {
+    const name = names2[i];
     let res;
     try {
       res = await apiFetch(`${apiUrl}/api/projects`, {
@@ -7287,9 +7300,9 @@ async function runDomain(opts) {
     return;
   }
   if (sub === "verify") {
-    const status = String(data.status ?? "");
-    if (status === "active") log.success(`${hostname} is live.`);
-    else if (status === "failed") log.error(`${hostname} is stopped \u2014 its verification record is missing.`);
+    const status2 = String(data.status ?? "");
+    if (status2 === "active") log.success(`${hostname} is live.`);
+    else if (status2 === "failed") log.error(`${hostname} is stopped \u2014 its verification record is missing.`);
     else log.plain(`${hostname} isn't verified yet \u2014 DNS changes can take a few minutes to spread.`);
     return;
   }
@@ -7352,7 +7365,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 fail3(res2, what) {
+  async function fail4(res2, what) {
     if (printedStructuredError(res2)) {
       process.exitCode = 1;
       return;
@@ -7373,7 +7386,7 @@ async function runShop(opts) {
   }
   if (sub === "list") {
     const res2 = await call(projectSkus);
-    if (!res2.ok) return fail3(res2, "read your shop");
+    if (!res2.ok) return fail4(res2, "read your shop");
     const body = await res2.json();
     if (opts.json) {
       log.plain(JSON.stringify(body, null, 2));
@@ -7418,7 +7431,7 @@ async function runShop(opts) {
         ...opts.resellable !== void 0 ? { resellable: opts.resellable } : {}
       })
     });
-    if (!res2.ok) return fail3(res2, "add that item");
+    if (!res2.ok) return fail4(res2, "add that item");
     const sku = await res2.json();
     if (opts.json) {
       log.plain(JSON.stringify(sku, null, 2));
@@ -7439,7 +7452,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 fail3(res2, "grant yourself a test copy");
+    if (!res2.ok) return fail4(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.");
@@ -7462,14 +7475,14 @@ async function runShop(opts) {
       return;
     }
     const res2 = await call(skuUrl, { method: "PATCH", body: JSON.stringify(patch) });
-    if (!res2.ok) return fail3(res2, "update that item");
+    if (!res2.ok) return fail4(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 fail3(res, "remove that item");
+  if (!res.ok) return fail4(res, "remove that item");
   log.success("Removed from the shop.");
   log.dim("  Players who already bought it keep it.");
 }
@@ -8475,6 +8488,7 @@ function tokenize(cmd) {
 function openUrl(url) {
   let command;
   let args;
+  if (process.env.GENEX_NO_BROWSER === "1") return;
   const custom = (process.env.GENEX_BROWSER || process.env.BROWSER)?.trim();
   const customParts = custom ? tokenize(custom) : [];
   if (customParts.length > 0) {
@@ -9297,10 +9311,10 @@ function reportLocalFiles(result, log, json) {
   }
 }
 function laneFailureAdvice(kind, outcomes) {
-  const run2 = outcomes.trailingFailed ?? (outcomes.completed > 0 ? 0 : outcomes.failed);
-  if (run2 < 2) return null;
+  const run4 = outcomes.trailingFailed ?? (outcomes.completed > 0 ? 0 : outcomes.failed);
+  if (run4 < 2) return null;
   const everSucceeded = outcomes.completed > 0;
-  const opening = everSucceeded ? `\u270B the last ${run2} ${kind} generations in this project all failed.` : `\u270B ${run2} ${kind} generations attempted in this project, ${run2} failed, none succeeded.`;
+  const opening = everSucceeded ? `\u270B the last ${run4} ${kind} generations in this project all failed.` : `\u270B ${run4} ${kind} generations attempted in this project, ${run4} failed, none succeeded.`;
   return `  ${c.bold(opening)} That pattern is the LANE, not your prompt \u2014 a fourth attempt bills the same and returns the same. Build this one in code, use a different lane, or tell the user in one plain line what is unavailable and carry on with the rest of the game.`;
 }
 function videoFailureAdvice(failures) {
@@ -9610,7 +9624,7 @@ function reportCharacterPreviewTerminal(view, log, opts = {}) {
   const intent = requestedBuildOf(view);
   const nextCommand = characterFinalizeCommand(view.id, intent);
   const sourceUrl = previewSource(view);
-  const stop = `STOP \u2014 show the front, back, left, and right views to the user. The high-detail source has ${sourceFaceCount} faces and remains preserved in R2. Ask them to approve a separate 10,000-face triangle rigging copy.`;
+  const stop2 = `STOP \u2014 show the front, back, left, and right views to the user. The high-detail source has ${sourceFaceCount} faces and remains preserved in R2. Ask them to approve a separate 10,000-face triangle rigging copy.`;
   if (opts.open) openUrl(views.front);
   if (opts.json) {
     writeJson({
@@ -9639,7 +9653,7 @@ function reportCharacterPreviewTerminal(view, log, opts = {}) {
   if (sourceUrl) log.plain(`  High-detail source: ${sourceUrl}`);
   log.plain("");
   log.plain(`  ${c.bold("\u{1F441}  Show these to the user")} \u2014 include all four views.`);
-  log.plain(`  ${c.bold(stop)}`);
+  log.plain(`  ${c.bold(stop2)}`);
   log.plain(`  After approval: ${c.cyan(nextCommand)}`);
   log.plain("");
 }
@@ -19416,8 +19430,8 @@ async function runAnims(opts) {
     `${parts.join(", ")} \u2192 ${c.cyan(ANIMS_DEST + path28.sep)}${addedBytes > 0 ? ` (+${formatMb(addedBytes)})` : ""}`
   );
   for (const [selector, entries] of resolved) {
-    const names = entries.filter((e) => !coreNames.has(e.name)).map((e) => e.name);
-    if (names.length > 0) log.dim(`  ${selector}: ${names.join(", ")}`);
+    const names2 = entries.filter((e) => !coreNames.has(e.name)).map((e) => e.name);
+    if (names2.length > 0) log.dim(`  ${selector}: ${names2.join(", ")}`);
   }
   log.info(
     `Wiring: load the ${c.cyan("genex-threejs-character-controller")} skill \u2192 "Animation packs" (loadCharacterClips picks these up automatically).`
@@ -20829,22 +20843,22 @@ async function context2(opts) {
   if (!token) return null;
   return { token, apiUrl };
 }
-async function readVideo(path37, log) {
+async function readVideo(path44, log) {
   let bytes;
   try {
-    bytes = await readFile(path37);
+    bytes = await readFile(path44);
   } catch {
-    log.error(`Can't read ${path37}.`);
+    log.error(`Can't read ${path44}.`);
     return null;
   }
   if (bytes.byteLength > MAX_VIDEO_BYTES) {
-    log.error(`${basename(path37)} is ${(bytes.byteLength / 1e6).toFixed(0)} MB \u2014 the limit is ${MAX_VIDEO_BYTES / 1e6} MB.`);
+    log.error(`${basename(path44)} 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, path37, bytes, log) {
-  const contentType = /\.mov$/i.test(path37) ? "video/quicktime" : "video/mp4";
+async function uploadVideo(apiUrl, token, characterId, path44, bytes, log) {
+  const contentType = /\.mov$/i.test(path44) ? "video/quicktime" : "video/mp4";
   const minted = await apiFetch(
     `${apiUrl}/api/characters/${encodeURIComponent(characterId)}/motions/video-url`,
     {
@@ -20859,7 +20873,7 @@ async function uploadVideo(apiUrl, token, characterId, path37, bytes, log) {
     return null;
   }
   const { uploadUrl, videoUrl } = await minted.json();
-  log.dim(`  uploading ${basename(path37)} (${(bytes.byteLength / 1e6).toFixed(1)} MB)\u2026`);
+  log.dim(`  uploading ${basename(path44)} (${(bytes.byteLength / 1e6).toFixed(1)} MB)\u2026`);
   const put = await fetch(uploadUrl, {
     method: "PUT",
     headers: { "Content-Type": contentType, "Content-Length": String(bytes.byteLength) },
@@ -21859,11 +21873,11 @@ function mAimhold(C, w) {
   const r = yawMed * Math.PI / 180;
   const axis = [Math.sin(r), 0, Math.cos(r)];
   const fwdF = fwdSrc.map(({ v, L }) => (v[0] * axis[0] + v[1] * axis[1] + v[2] * axis[2]) / (L + 1e-9));
-  let run2 = 0, best = 0;
+  let run4 = 0, best = 0;
   for (let i = 0; i < fwdF.length; i++) {
     const ok = dev[i] < 15 && dyF[i] < -0.22 && gapF[i] > 0.18 && gapF[i] < 0.46 && fwdF[i] > 0.75 && hunchF[i] < 16;
-    run2 = ok ? run2 + 1 : 0;
-    best = Math.max(best, run2);
+    run4 = ok ? run4 + 1 : 0;
+    best = Math.max(best, run4);
   }
   let holdBest = 0, holdBestScore = -Infinity;
   for (let i = 0; i < fwdF.length; i++) {
@@ -22217,15 +22231,15 @@ function cutOneshot(t, cfg) {
   const cc = folded(t);
   const air = cc.map((c2) => c2[0] === 0 && c2[1] === 0);
   let best = null;
-  let run2 = null;
+  let run4 = null;
   for (let f = 0; f < air.length; f++) {
-    if (air[f]) run2 = run2 ? [run2[0], f] : [f, f];
+    if (air[f]) run4 = run4 ? [run4[0], f] : [f, f];
     else {
-      if (run2 && (!best || run2[1] - run2[0] > best[1] - best[0])) best = run2;
-      run2 = null;
+      if (run4 && (!best || run4[1] - run4[0] > best[1] - best[0])) best = run4;
+      run4 = null;
     }
   }
-  if (run2 && (!best || run2[1] - run2[0] > best[1] - best[0])) best = run2;
+  if (run4 && (!best || run4[1] - run4[0] > best[1] - best[0])) best = run4;
   let s, e;
   if (best) {
     s = best[0];
@@ -22469,8 +22483,8 @@ async function expandTakes(selectors) {
   for (const sel of selectors) {
     const st = await fs30.stat(sel).catch(() => null);
     if (st?.isDirectory()) {
-      const names = await fs30.readdir(sel);
-      for (const n of names.sort()) if (n.endsWith(".npz")) out.push(path31.join(sel, n));
+      const names2 = await fs30.readdir(sel);
+      for (const n of names2.sort()) if (n.endsWith(".npz")) out.push(path31.join(sel, n));
     } else if (st?.isFile()) {
       out.push(sel);
     } else {
@@ -22758,7 +22772,7 @@ async function runBlender(opts) {
     return 1;
   }
   if (sub === "serve") {
-    const { serveLocalBlender } = await import("./blender-serve-66OHC4ML.js");
+    const { serveLocalBlender } = await import("./blender-serve-EH2MOW3U.js");
     const port = Number(process.env.GENEX_BLENDER_PORT ?? 8088);
     log.step(`Starting a local Blender service on port ${port}`);
     log.plain(
@@ -22767,7 +22781,7 @@ async function runBlender(opts) {
     return serveLocalBlender({ port, log });
   }
   if (sub === "mcp") {
-    const { runBlenderMcp } = await import("./blender-mcp-6TEAE65U.js");
+    const { runBlenderMcp } = await import("./blender-mcp-HKT7N5BQ.js");
     return runBlenderMcp();
   }
   if (sub === "seat") {
@@ -23265,10 +23279,618 @@ async function runAssetNew(options) {
 }
 
 // src/commands/tools.ts
-import path35 from "path";
+import path36 from "path";
 
 // src/commands/doctor.ts
+import path35 from "path";
+
+// src/commands/llm.ts
+import fs33 from "fs/promises";
 import path34 from "path";
+import { randomUUID as randomUUID2 } from "crypto";
+var SUBS3 = ["models", "bench", "price"];
+var LLM_BENCH_APPROVAL_REQUIRED = "STOP: `genex llm bench` runs the real model and spends YOUR OWN coin \u2014 your wallet, not a player's, and one this build's asset allowance cannot see. Re-run with --max-coins <n> --user-approved only after the person at the keyboard agreed to the number.";
+var LLM_LANE_OFF_LINE = "The runtime LLM lane is off on this stand \u2014 in-game generate() answers 404 here, and nothing can be benchmarked.";
+var LLM_TOOLS_CONVERT_HINT = [
+  "In-game model calls need a hosted game. This folder is a Genex Tools workspace, so nothing here",
+  "can call a model at play time yet \u2014 and the player, not you, is who pays for one that does.",
+  "Ask the user first; on their yes run `npx genex init --convert`, then load the genex-tool-llm card."
+];
+var LLM_BENCH_FILE = ".genex/llm-bench.json";
+var DEFAULT_BENCH_SAMPLES = 3;
+var DEFAULT_SAMPLE_TIMEOUT_SEC = 180;
+async function readRuntimeLane(apiUrl, token) {
+  const empty = (state) => ({
+    state,
+    models: null,
+    recommendedDeclaredHeadroomBps: null,
+    externalProviders: null
+  });
+  try {
+    const res = await apiFetch(`${apiUrl}/api/runtime/models`, {
+      ...token ? { headers: { Authorization: `Bearer ${token}` } } : {},
+      signal: AbortSignal.timeout(6e3)
+    });
+    if (res.status === 404) return empty("off");
+    if (res.status === 503) return empty("unavailable");
+    if (!res.ok) return empty("unknown");
+    const body = await res.json().catch(() => null);
+    if (!body || !Array.isArray(body.models)) return empty("unknown");
+    return {
+      state: "live",
+      models: body.models,
+      recommendedDeclaredHeadroomBps: typeof body.recommendedDeclaredHeadroomBps === "number" && Number.isFinite(body.recommendedDeclaredHeadroomBps) ? body.recommendedDeclaredHeadroomBps : null,
+      externalProviders: Array.isArray(body.externalProviders) ? body.externalProviders : null
+    };
+  } catch {
+    return empty("unknown");
+  }
+}
+function percentile2(values, p) {
+  if (values.length === 0) return null;
+  const sorted = [...values].sort((a, b) => a - b);
+  const rank2 = Math.ceil(p / 100 * sorted.length);
+  return sorted[Math.min(sorted.length - 1, Math.max(0, rank2 - 1))];
+}
+function recommendEstimateCoins(p95, headroomBps) {
+  return Math.max(1, Math.ceil(p95 * (1e4 + headroomBps) / 1e4));
+}
+function recommendPerCallMaxCoins(p95, max, headroomBps) {
+  return Math.max(recommendEstimateCoins(p95, headroomBps), recommendEstimateCoins(max, headroomBps));
+}
+function usdPerMillion(value) {
+  return `$${value.toFixed(value < 1 ? 4 : 2)}`;
+}
+function usd(value) {
+  return value === null ? "unknown" : `$${value.toFixed(6)}`;
+}
+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 = {}) => {
+    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(", ")}.`);
+    return;
+  }
+  if (sub === "price") {
+    await reportSavedPrice(cwd, opts, log);
+    return;
+  }
+  const ws = await resolveWorkspace(cwd);
+  const toolsOnly = ws.mode === "tools" && !ws.hosted;
+  if (sub === "bench") {
+    if (opts.maxCoins === void 0 || opts.userApproved !== true) {
+      fail4("llm bench", LLM_BENCH_APPROVAL_REQUIRED);
+      return;
+    }
+    if (!Number.isInteger(opts.maxCoins) || opts.maxCoins < 1) {
+      fail4("llm bench", `--max-coins takes a whole number of coin, 1 or more (got ${String(opts.maxCoins)}).`);
+      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-coins <n> --user-approved.');
+      return;
+    }
+    if (opts.jsonOutput && opts.textOutput) {
+      fail4("llm bench", "Pass --json-output or --text, not both.");
+      return;
+    }
+    if (toolsOnly) {
+      if (opts.json) writeJsonLine({ command: "llm bench", status: "failed", error: "`genex llm bench` is not part of Genex Tools." });
+      else {
+        reportPlatformRefused(log, "llm bench");
+        log.plain(`  ${c.cyan("\u2192")} A model that runs while people PLAY is a platform feature: the player pays and approves it.`);
+        log.plain(`    Ask the user, and on their yes: ${c.cyan("npx genex init --convert")} \u2014 then the ${c.cyan("genex-tool-llm")} card.`);
+      }
+      process.exitCode = 1;
+      return;
+    }
+  }
+  const meta = await readProject(cwd);
+  if (sub === "bench" && !meta?.id) {
+    fail4(
+      "llm bench",
+      "This folder isn't linked to a game \u2014 a benchmark is billed to a project you own."
+    );
+    if (!opts.json) {
+      log.dim(`  Run ${c.cyan("genex link")} (or ${c.cyan("genex list")} to find the slug) first.`);
+    }
+    return;
+  }
+  const apiUrl = getApiUrl(opts.apiUrl ?? meta?.apiUrl);
+  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.");
+      return;
+    }
+    log.plain("Not signed in \u2014 connecting\u2026");
+    try {
+      assertAuthorizationOrigin(apiUrl, getApiUrl(opts.apiUrl));
+      token = await authorize(apiUrl, getAuthUrl(opts.authUrl), {
+        envPath: opts.envPath,
+        log,
+        inlineWaitMs: opts.timeoutSec ? opts.timeoutSec * 1e3 : void 0
+      });
+    } catch (err) {
+      if (err instanceof AuthPendingError) {
+        printAuthHandoff(log, err);
+        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)}`);
+      return;
+    }
+    await writeUserToken(token, opts.envPath, apiUrl);
+  }
+  if (sub === "models") {
+    await reportModels(apiUrl, token, opts, log, toolsOnly);
+    return;
+  }
+  await runBench({ apiUrl, token, projectId: meta.id, cwd, opts, log });
+}
+async function reportModels(apiUrl, token, opts, log, toolsOnly = false) {
+  const probe = await apiFetch(`${apiUrl}/api/runtime/models`, {
+    headers: { Authorization: `Bearer ${token}` }
+  }).catch(() => null);
+  if (probe?.status === 403) {
+    const body = await probe.json().catch(() => ({}));
+    if (!printedStructuredError(probe)) {
+      log.error(
+        body.error === "credential_scope" ? "This credential can't reach the runtime lane." : "The server refused this credential for the runtime lane."
+      );
+      log.dim("  An API key or an MCP connector token is scoped to the asset routes and can never");
+      log.dim("  benchmark. Sign this machine in with the CLI's own device-code flow instead:");
+      log.dim(`  ${c.cyan("genex auth")} \u2014 it prints a short link and a code; approve it on any device.`);
+    }
+    if (opts.json) {
+      writeJsonLine({
+        command: "llm models",
+        status: "failed",
+        error: body.error ?? "forbidden",
+        enabled: null,
+        models: null,
+        externalProviders: null,
+        recommendedDeclaredHeadroomBps: null,
+        convertHint: toolsOnly ? LLM_TOOLS_CONVERT_HINT.join(" ") : null
+      });
+    }
+    process.exitCode = 1;
+    return;
+  }
+  const lane = await readRuntimeLane(apiUrl, token);
+  if (opts.json) {
+    writeJsonLine({
+      command: "llm models",
+      status: lane.state,
+      error: null,
+      enabled: lane.state === "live",
+      models: lane.models,
+      externalProviders: lane.externalProviders,
+      recommendedDeclaredHeadroomBps: lane.recommendedDeclaredHeadroomBps,
+      // Always present, `null` off a tools workspace — the same
+      // every-key-always-present rule the other keys follow, so a reader can
+      // tell "no hint" from "a CLI that predates the hint".
+      convertHint: toolsOnly ? LLM_TOOLS_CONVERT_HINT.join(" ") : null
+    });
+    if (lane.state === "unknown") process.exitCode = 1;
+    return;
+  }
+  const printConvertHint = () => {
+    if (!toolsOnly) return;
+    log.plain("");
+    for (const line of LLM_TOOLS_CONVERT_HINT) log.dim(`  ${line}`);
+  };
+  log.plain(c.bold("genex llm models"));
+  log.dim(`  ${apiUrl}`);
+  log.plain("");
+  if (lane.state === "off") {
+    log.plain(`  ${LLM_LANE_OFF_LINE}`);
+    log.dim("  Build the feature without an in-game model, or ask the operator to turn the lane on.");
+    printConvertHint();
+    return;
+  }
+  if (lane.state === "unavailable") {
+    log.warn("  This stand has the lane on but cannot serve its model list.");
+    log.dim("  That is a server configuration problem, not yours \u2014 nothing here can be benchmarked yet.");
+    printConvertHint();
+    return;
+  }
+  if (lane.state === "unknown" || !lane.models) {
+    log.error(`  Couldn't read the runtime lane from ${apiUrl}.`);
+    log.dim(`  Check the network, then ${c.cyan("genex doctor")}.`);
+    process.exitCode = 1;
+    return;
+  }
+  log.plain(`  ${lane.models.length} model${lane.models.length === 1 ? "" : "s"} live:`);
+  for (const m of lane.models) {
+    log.plain(
+      `    ${c.cyan(m.id)}  ${m.label} \u2014 ${usdPerMillion(m.inputUsdPerMillion)} in / ${usdPerMillion(m.outputUsdPerMillion)} out per million tokens`
+    );
+  }
+  if (lane.externalProviders && lane.externalProviders.length > 0) {
+    log.plain("");
+    log.plain(`  Personal plans offered here: ${lane.externalProviders.map((p) => p.label).join(", ")}`);
+  }
+  log.plain("");
+  if (lane.recommendedDeclaredHeadroomBps === null) {
+    log.dim("  This stand serves no recommended headroom, so no price can be recommended from a bench.");
+  } else {
+    log.dim(`  Recommended headroom over benchmarked coins on this stand: ${lane.recommendedDeclaredHeadroomBps} bps.`);
+  }
+  if (toolsOnly) {
+    printConvertHint();
+    return;
+  }
+  log.dim("  Those per-million rates are the PROVIDER's; what your game is charged is the platform");
+  log.dim(`  tariff on top, which only a real call reveals: ${c.cyan('genex llm bench "<prompt>" --max-coins <n> --user-approved')}`);
+}
+async function runBench(args) {
+  const { apiUrl, token, projectId, cwd, opts, log } = args;
+  const maxCoins = opts.maxCoins;
+  const samples = opts.samples ?? DEFAULT_BENCH_SAMPLES;
+  const prompt = opts.benchPrompt.trim();
+  const auth = { Authorization: `Bearer ${token}`, "Content-Type": "application/json" };
+  const call = (url, init2) => apiFetch(url, { ...init2, headers: { ...auth, ...init2?.headers ?? {} } });
+  let schema;
+  if (opts.schemaPath) {
+    try {
+      schema = JSON.parse(await fs33.readFile(path34.resolve(cwd, opts.schemaPath), "utf8"));
+    } catch (err) {
+      benchFailed(opts, log, `Couldn't read --schema ${opts.schemaPath}: ${err instanceof Error ? err.message : String(err)}`);
+      return;
+    }
+  }
+  const outputFormat = schema !== void 0 || opts.jsonOutput ? "json" : "text";
+  if (schema !== void 0 && opts.textOutput) {
+    benchFailed(opts, log, "--schema asks for a structured answer, so --text cannot apply. Drop one of them.");
+    return;
+  }
+  const lane = await readRuntimeLane(apiUrl, token);
+  if (lane.state !== "live" || !lane.models || lane.models.length === 0) {
+    if (lane.state === "off") {
+      if (opts.json) writeJsonLine({ ...emptyBenchJson(apiUrl, projectId, prompt, outputFormat, samples, maxCoins, opts), status: "off", error: null });
+      else {
+        log.plain(LLM_LANE_OFF_LINE);
+        log.dim("  Nothing was spent.");
+      }
+      return;
+    }
+    benchFailed(
+      opts,
+      log,
+      lane.state === "unavailable" ? "This stand has the lane on but cannot serve its model list \u2014 nothing can be benchmarked yet." : `Couldn't read the runtime lane from ${apiUrl}.`
+    );
+    return;
+  }
+  const modelId = opts.modelId ?? lane.models[0].id;
+  if (!lane.models.some((m) => m.id === modelId)) {
+    benchFailed(opts, log, `This stand does not serve ${modelId}. Run \`genex llm models\` for the ids it does.`);
+    return;
+  }
+  const balanceBefore = await readCoinBalance(apiUrl, token);
+  if (!opts.json) {
+    log.plain(c.bold("genex llm bench"));
+    log.dim(`  ${apiUrl}`);
+    log.plain("");
+    log.plain(`  Model        ${c.cyan(modelId)}`);
+    log.plain(`  Samples      ${samples} real attempt${samples === 1 ? "" : "s"}, ${outputFormat} output`);
+    log.plain(`  Approved     ${maxCoins} coin per attempt \u2014 at worst ${maxCoins * samples} coin for this run`);
+    log.plain(
+      `  Balance      ${balanceBefore === null ? "couldn't be read" : `${balanceBefore} coin spendable`}`
+    );
+    log.plain("");
+  }
+  const base = `${apiUrl}/api/runtime/development/projects/${encodeURIComponent(projectId)}/generations`;
+  const results = [];
+  let inflight = null;
+  const onSigint = () => {
+    const target = inflight;
+    inflight = null;
+    if (!opts.json) log.warn("Stopping \u2014 cancelling the attempt in flight.");
+    void (async () => {
+      if (target) {
+        await call(`${base}/${encodeURIComponent(target)}/cancel`, { method: "POST" }).catch(() => {
+        });
+      }
+      process.exit(130);
+    })();
+  };
+  process.once("SIGINT", onSigint);
+  try {
+    for (let i = 0; i < samples; i++) {
+      const res = await call(base, {
+        method: "POST",
+        body: JSON.stringify({
+          maxCoins,
+          request: {
+            idempotencyKey: `bench-${randomUUID2()}`,
+            modelId,
+            prompt,
+            outputFormat,
+            ...schema !== void 0 ? { schema } : {}
+          }
+        })
+      });
+      if (!res.ok) {
+        const stop2 = await explainBenchRefusal(res, log, opts, i, results.length);
+        if (stop2) break;
+        continue;
+      }
+      const started = await res.json().catch(() => ({}));
+      if (!started.id) {
+        results.push({ id: null, status: null, billingStatus: null, chargedCoins: null, costUsd: null, error: "no_generation_id" });
+        continue;
+      }
+      inflight = started.id;
+      const settled = await pollSettled(call, `${base}/${encodeURIComponent(started.id)}`, opts.timeoutSec ?? DEFAULT_SAMPLE_TIMEOUT_SEC);
+      inflight = null;
+      const row = {
+        id: started.id,
+        status: settled?.status ?? null,
+        billingStatus: settled?.billingStatus ?? null,
+        chargedCoins: typeof settled?.chargedCoins === "number" ? settled.chargedCoins : null,
+        costUsd: typeof settled?.usage?.costUsd === "number" ? settled.usage.costUsd : null,
+        error: settled?.error ?? (settled ? null : "timed_out")
+      };
+      results.push(row);
+      if (!opts.json) {
+        log.plain(
+          `  ${row.status === "succeeded" ? c.green("\u2713") : c.yellow("!")} sample ${i + 1}  ${String(row.chargedCoins ?? "\u2014").padStart(4)} coin charged \xB7 provider ${usd(row.costUsd)}${row.error ? ` \xB7 ${row.error}` : ""}`
+        );
+      }
+    }
+  } finally {
+    process.removeListener("SIGINT", onSigint);
+  }
+  const charged = results.filter((r) => r.billingStatus === "final" && typeof r.chargedCoins === "number").map((r) => r.chargedCoins);
+  const settledCount = charged.length;
+  const p50 = percentile2(charged, 50);
+  const p95 = percentile2(charged, 95);
+  const max = charged.length ? Math.max(...charged) : null;
+  const headroomBps = lane.recommendedDeclaredHeadroomBps;
+  const recommended = p95 !== null && headroomBps !== null ? recommendEstimateCoins(p95, headroomBps) : null;
+  const ceiling = p95 !== null && max !== null && headroomBps !== null ? recommendPerCallMaxCoins(p95, max, headroomBps) : null;
+  const balanceAfter = await readCoinBalance(apiUrl, token);
+  const record = {
+    v: 1,
+    ranAt: (/* @__PURE__ */ new Date()).toISOString(),
+    apiUrl,
+    projectId,
+    modelId,
+    prompt,
+    outputFormat,
+    samples,
+    completed: settledCount,
+    chargedCoins: charged,
+    p50,
+    p95,
+    max,
+    recommendedDeclaredHeadroomBps: headroomBps,
+    recommendedEstimateCoins: recommended,
+    recommendedPerCallMaxCoins: ceiling
+  };
+  const savedTo = await saveBench(cwd, record);
+  if (opts.json) {
+    writeJsonLine({
+      command: "llm bench",
+      status: charged.length > 0 ? "ok" : "failed",
+      error: charged.length > 0 ? null : "no_sample_settled",
+      apiUrl,
+      projectId,
+      modelId,
+      prompt,
+      outputFormat,
+      schemaPath: opts.schemaPath ?? null,
+      samples,
+      completed: settledCount,
+      maxCoinsPerSample: maxCoins,
+      balanceBefore,
+      balanceAfter,
+      results,
+      chargedCoins: { p50, p95, max },
+      recommendedDeclaredHeadroomBps: headroomBps,
+      recommendedEstimateCoins: recommended,
+      recommendedPerCallMaxCoins: ceiling,
+      savedTo
+    });
+    if (charged.length === 0) process.exitCode = 1;
+    return;
+  }
+  log.plain("");
+  if (charged.length === 0) {
+    log.error("  No sample settled, so there is nothing to price from.");
+    process.exitCode = 1;
+    return;
+  }
+  log.plain(c.bold("  Charged coins"));
+  log.plain(`    p50 ${p50}   p95 ${p95}   max ${max}   (${charged.length} of ${samples} settled)`);
+  if (balanceBefore !== null && balanceAfter !== null) {
+    log.plain(`    Balance ${balanceBefore} \u2192 ${balanceAfter} coin spendable`);
+  }
+  log.plain("");
+  printRecommendation(log, record);
+  if (savedTo) log.dim(`  Saved to ${savedTo} \u2014 re-read it any time with ${c.cyan("genex llm price")}.`);
+}
+function printRecommendation(log, record) {
+  if (record.recommendedEstimateCoins === null || record.p95 === null) {
+    log.warn("  No price recommended.");
+    log.dim(
+      record.recommendedDeclaredHeadroomBps === null ? "  This stand served no recommended headroom, and the multiplier is the server's to set \u2014" : "  No sample settled, so there is no p95 to build a price on \u2014"
+    );
+    log.dim("  declaring a number from this run would be a guess dressed as a measurement.");
+    return;
+  }
+  log.plain(c.bold(`  Declare estimateCoins: ${record.recommendedEstimateCoins}`));
+  log.dim(
+    `  = p95 of charged coins (${record.p95}) plus this stand's recommended headroom (${record.recommendedDeclaredHeadroomBps} bps),`
+  );
+  log.dim(`  measured over ${record.completed} settled attempt${record.completed === 1 ? "" : "s"} on ${record.modelId}.`);
+  log.dim("  That number is a PRICE: a started attempt is charged in full, including one that fails.");
+  if (record.recommendedPerCallMaxCoins != null) {
+    log.plain(c.bold(`  Grant perCallMaxCoins: ${record.recommendedPerCallMaxCoins}`));
+    log.dim(`  = the same headroom over the worst sample (${record.max}), and never below the price above it.`);
+    log.dim("  The ceiling is the price's room to be wrong; declaring one under the price is refused.");
+  }
+}
+async function explainBenchRefusal(res, log, opts, index, settledSoFar) {
+  if (printedStructuredError(res)) return true;
+  const body = await res.json().catch(() => ({}));
+  if (opts.json) return res.status !== 429;
+  if (res.status === 404 && body.error === "not_found") {
+    log.error(`  ${LLM_LANE_OFF_LINE}`);
+    return true;
+  }
+  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 true;
+  }
+  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 true;
+  }
+  if (res.status === 402) {
+    log.error("  Not enough coin to start the attempt.");
+    return true;
+  }
+  log.error(
+    `  Sample ${index + 1} was refused: ${body.message ?? body.error ?? `HTTP ${res.status}`}${settledSoFar > 0 ? " (earlier samples still count)" : ""}`
+  );
+  return res.status >= 500 || res.status === 401 || res.status === 403;
+}
+async function pollSettled(call, url, timeoutSec) {
+  const deadline = Date.now() + timeoutSec * 1e3;
+  let last = null;
+  while (Date.now() < deadline) {
+    const res = await call(url).catch(() => null);
+    if (res?.ok) {
+      last = await res.json().catch(() => null);
+      if (last?.billingStatus === "final") return last;
+    }
+    await new Promise((r) => setTimeout(r, 1500));
+  }
+  return last;
+}
+async function readCoinBalance(apiUrl, token) {
+  try {
+    const res = await apiFetch(`${apiUrl}/api/coin/balance`, {
+      headers: { Authorization: `Bearer ${token}` },
+      signal: AbortSignal.timeout(6e3)
+    });
+    if (!res.ok) return null;
+    const body = await res.json().catch(() => null);
+    return typeof body?.spendable === "number" ? body.spendable : null;
+  } catch {
+    return null;
+  }
+}
+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");
+    return LLM_BENCH_FILE;
+  } catch {
+    return null;
+  }
+}
+function benchFailed(opts, log, message) {
+  if (opts.json) writeJsonLine({ command: "llm bench", status: "failed", error: message });
+  else log.error(message);
+  process.exitCode = 1;
+}
+function emptyBenchJson(apiUrl, projectId, prompt, outputFormat, samples, maxCoins, opts) {
+  return {
+    command: "llm bench",
+    apiUrl,
+    projectId,
+    modelId: opts.modelId ?? null,
+    prompt,
+    outputFormat,
+    schemaPath: opts.schemaPath ?? null,
+    samples,
+    completed: 0,
+    maxCoinsPerSample: maxCoins,
+    balanceBefore: null,
+    balanceAfter: null,
+    results: [],
+    chargedCoins: { p50: null, p95: null, max: null },
+    recommendedDeclaredHeadroomBps: null,
+    recommendedEstimateCoins: null,
+    recommendedPerCallMaxCoins: null,
+    savedTo: null
+  };
+}
+async function reportSavedPrice(cwd, opts, log) {
+  let record = null;
+  try {
+    record = JSON.parse(await fs33.readFile(path34.join(cwd, LLM_BENCH_FILE), "utf8"));
+  } catch {
+    record = null;
+  }
+  if (!record) {
+    if (opts.json) {
+      writeJsonLine({
+        command: "llm price",
+        status: "failed",
+        error: "no_bench",
+        ranAt: null,
+        modelId: null,
+        samples: null,
+        completed: null,
+        p50: null,
+        p95: null,
+        max: null,
+        recommendedDeclaredHeadroomBps: null,
+        recommendedEstimateCoins: null,
+        recommendedPerCallMaxCoins: null,
+        savedTo: null
+      });
+    } else {
+      log.error("Nothing has been benchmarked in this folder yet.");
+      log.dim(`  Run ${c.cyan('genex llm bench "<prompt>" --max-coins <n> --user-approved')} first.`);
+    }
+    process.exitCode = 1;
+    return;
+  }
+  if (opts.json) {
+    writeJsonLine({
+      command: "llm price",
+      status: record.recommendedEstimateCoins === null ? "failed" : "ok",
+      error: record.recommendedEstimateCoins === null ? "no_recommendation" : null,
+      ranAt: record.ranAt ?? null,
+      modelId: record.modelId ?? null,
+      samples: record.samples ?? null,
+      completed: record.completed ?? null,
+      p50: record.p50 ?? null,
+      p95: record.p95 ?? null,
+      max: record.max ?? null,
+      recommendedDeclaredHeadroomBps: record.recommendedDeclaredHeadroomBps ?? null,
+      recommendedEstimateCoins: record.recommendedEstimateCoins ?? null,
+      recommendedPerCallMaxCoins: record.recommendedPerCallMaxCoins ?? null,
+      savedTo: LLM_BENCH_FILE
+    });
+    if (record.recommendedEstimateCoins === null) process.exitCode = 1;
+    return;
+  }
+  log.plain(c.bold("genex llm price"));
+  log.dim(`  from ${LLM_BENCH_FILE}, benchmarked ${record.ranAt}`);
+  log.plain("");
+  printRecommendation(log, record);
+  if (record.recommendedEstimateCoins === null) process.exitCode = 1;
+}
+function writeJsonLine(value) {
+  process.stdout.write(`${JSON.stringify(value)}
+`);
+}
+
+// src/commands/doctor.ts
 var LANE_ORDER = [
   "model",
   "image",
@@ -23339,15 +23961,18 @@ async function runDoctor(opts = {}) {
   let credits = null;
   let lanes = null;
   let legal = null;
+  let runtime = null;
   if (authState === "ok" && token) {
-    [credits, lanes, legal] = await Promise.all([
+    [credits, lanes, legal, runtime] = await Promise.all([
       fetchCredits(apiUrl, token),
       fetchLanes(apiUrl, token),
-      fetchLegalStatus(apiUrl, token)
+      fetchLegalStatus(apiUrl, token),
+      readRuntimeLane(apiUrl, token)
     ]);
   }
   rows.push(termsRow(authState, legal));
   rows.push(creditsRow(authState, credits));
+  rows.push(runtimeRow(authState, runtime, mode === "tools"));
   if (opts.json) {
     process.stdout.write(
       JSON.stringify(
@@ -23366,6 +23991,10 @@ async function runDoctor(opts = {}) {
           terms: legal,
           credits,
           lanes: lanes ? { paused: lanes.paused, lanes: lanes.lanes } : null,
+          // Same always-present rule as `assetsMode`: a consumer must be able
+          // to tell a CLI that KNOWS the runtime lane (key present, object or
+          // null) from one that predates it (no key at all).
+          runtime,
           ok: !rows.some((r) => r.bad)
         },
         null,
@@ -23504,6 +24133,30 @@ function creditsRow(state, info) {
     fix: info.balance <= 0 ? "Out of credits \u2014 generation is refused until the refill or a top-up." : void 0
   };
 }
+function runtimeRow(state, lane, toolsOnly = false) {
+  if (state !== "ok") return { label: "Runtime", value: "\u2014 (sign in first)" };
+  const convertFix = "In-game calls need a hosted game, and the PLAYER pays for them \u2014 ask the user, then `npx genex init --convert`; the genex-tool-llm card has the offer to make.";
+  switch (lane?.state) {
+    case "live": {
+      const n = lane.models?.length ?? 0;
+      return {
+        label: "Runtime",
+        value: `in-game LLM lane live \xB7 ${n} model${n === 1 ? "" : "s"}`,
+        fix: toolsOnly ? convertFix : 'Price a call before a game declares one: `npx genex llm bench "<prompt>" --max-coins <n> --user-approved`.'
+      };
+    }
+    case "off":
+      return {
+        label: "Runtime",
+        value: "in-game LLM lane off on this stand",
+        fix: "generate() in a game answers 404 here \u2014 build the feature without a model, or ask the operator."
+      };
+    case "unavailable":
+      return { label: "Runtime", value: "in-game LLM lane on, but its model list can't be served" };
+    default:
+      return { label: "Runtime", value: "couldn't be read from this server" };
+  }
+}
 function shortDate(iso) {
   const d = new Date(iso);
   return Number.isNaN(d.getTime()) ? iso : d.toLocaleDateString("en-US", { month: "short", day: "numeric" });
@@ -23549,7 +24202,7 @@ async function fetchLegalStatus(apiUrl, token) {
 }
 async function firstSkillsMarker() {
   for (const target of resolveAgentTargets()) {
-    const marker = await readSkillsMarker(path34.join(target.baseDir, "skills"));
+    const marker = await readSkillsMarker(path35.join(target.baseDir, "skills"));
     if (marker) return marker;
   }
   return null;
@@ -23600,8 +24253,8 @@ async function runTools(opts) {
   let totalNew = 0;
   let totalUpdated = 0;
   for (const t of targets) {
-    const dest = path35.join(t.baseDir, "skills");
-    const { copied, updated } = await copyTemplates(path35.join(templatesDir, "skills"), dest, {
+    const dest = path36.join(t.baseDir, "skills");
+    const { copied, updated } = await copyTemplates(path36.join(templatesDir, "skills"), dest, {
       filter: (rel) => skillFamilyFilter("tools")(`skills/${rel}`)
     });
     await pruneRemovedSkills(dest, log);
@@ -23661,8 +24314,8 @@ async function runTools(opts) {
 }
 
 // src/commands/budget.ts
-import fs33 from "fs/promises";
-import path36 from "path";
+import fs34 from "fs/promises";
+import path37 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) {
@@ -23670,7 +24323,7 @@ function internalKind(kind) {
 }
 async function isGenexProject(cwd) {
   try {
-    await fs33.access(path36.join(cwd, ".genex"));
+    await fs34.access(path37.join(cwd, ".genex"));
     return true;
   } catch {
     return false;
@@ -23691,25 +24344,25 @@ async function runBudget(opts = {}) {
   const log = createLogger({ quiet: opts.quiet || opts.json });
   const cwd = opts.cwd ?? process.cwd();
   const config = budgetConfig();
-  const fail3 = (message) => {
+  const fail4 = (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) {
-    fail3(BUDGET_APPROVAL_REQUIRED);
+    fail4(BUDGET_APPROVAL_REQUIRED);
     return;
   }
   if (setting && (!Number.isInteger(opts.assets) || opts.assets < 0)) {
-    fail3(`--assets takes a whole number of credits, 0 or more (got ${String(opts.assets)}).`);
+    fail4(`--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) {
-    fail3("Not authorized. Run `genex init` first to sign in.");
+    fail4("Not authorized. Run `genex init` first to sign in.");
     return;
   }
   const snapshot = await fetchCreditsSnapshot(apiUrl, token);
@@ -23727,7 +24380,7 @@ async function runBudget(opts = {}) {
     };
     persisted = await writeBudgetStore(cwd, store);
     if (!persisted) {
-      fail3("This folder is not a Genex project (no .genex/), so the allowance has nowhere to live. Run this inside the game folder.");
+      fail4("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)) {
@@ -23818,16 +24471,1560 @@ async function runBudget(opts = {}) {
   if (!snapshot && !setting) process.exitCode = 1;
 }
 
-// src/lib/costs.ts
-var TYPICAL_CREDITS = {
-  model: 35,
-  // 46 from a reference image; --texture standard 23, --no-texture 12, --geometry detailed 58, --quad 41, --low-poly 46, --parts 58 quote off the estimate
-  image: 7,
-  // GPT Image 2.5 at high, the default; --quality xhigh/max, --candidates, --edit and 4K quote higher, --quality low/medium and --transparent quote lower
-  texture: 9,
-  // gemini-3.1-flash-image, 1K square
-  sfx: 2,
-  music: 27,
+// src/commands/player.ts
+import fs39 from "fs";
+import fsp2 from "fs/promises";
+import os12 from "os";
+import path43 from "path";
+import { spawn as spawn8 } from "child_process";
+
+// src/lib/player/paths.ts
+import os8 from "os";
+import path38 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");
+  return {
+    credential: path38.join(dir, "player.json"),
+    state: path38.join(dir, "player-state.json"),
+    relaunch: path38.join(dir, "player-relaunch.json"),
+    logDir,
+    log: path38.join(logDir, "player.log"),
+    errorLog: path38.join(logDir, "player.error.log")
+  };
+}
+
+// src/lib/player/store.ts
+import fs35 from "fs/promises";
+import path39 from "path";
+async function readPlayerInstall(home) {
+  try {
+    const raw = await fs35.readFile(playerPaths(home).credential, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed.token !== "string" || typeof parsed.apiUrl !== "string") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function writePlayerInstall(install2, home) {
+  const file = playerPaths(home).credential;
+  const record = { ...install2, apiUrl: normalizeApiOrigin(install2.apiUrl) };
+  await writeSecretFile(file, JSON.stringify(record, null, 2) + "\n");
+  return file;
+}
+function installExpired(install2, now = Date.now()) {
+  const at = Date.parse(install2.expiresAt);
+  return Number.isFinite(at) && at <= now;
+}
+function describeInstall(install2) {
+  return {
+    apiUrl: install2.apiUrl,
+    watcherId: install2.watcherId ?? null,
+    label: install2.label ?? null,
+    installedAt: install2.installedAt,
+    version: install2.version,
+    expiresAt: install2.expiresAt
+  };
+}
+async function readPlayerState(home) {
+  try {
+    return JSON.parse(await fs35.readFile(playerPaths(home).state, "utf8"));
+  } catch {
+    return null;
+  }
+}
+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 });
+  } catch {
+  }
+}
+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(() => {
+    });
+    if (existed) removed.push(file);
+  }
+  return removed;
+}
+
+// src/lib/player/auth.ts
+var MIN_POLL_INTERVAL_MS2 = 1e3;
+var DEFAULT_PLAYER_WAIT_MS = 10 * 60 * 1e3;
+var REASSURE_EVERY_MS2 = 30 * 1e3;
+var PLAYER_NOT_APPROVED = "Nobody approved this machine, so nothing was installed. Re-run `genex player install` when you can open the link.";
+var sleep4 = (ms) => new Promise((r) => setTimeout(r, ms));
+async function authorizePlayer(apiBaseUrl, options) {
+  const apiUrl = normalizeApiOrigin(apiBaseUrl);
+  const { log, waitMs = DEFAULT_PLAYER_WAIT_MS, open = openBrowser } = options;
+  const started = await startPlayerDeviceAuth(apiUrl, options.label);
+  log.plain("");
+  log.step("Approve this machine for in-game model requests.");
+  log.plain([
+    "",
+    `  ${c.cyan("\u2192")} Open:  ${c.cyan(started.verifyUrl)}`,
+    `  ${c.cyan("\u2192")} Code:  ${c.bold(formatUserCode(started.userCode))}`,
+    "",
+    "  The card names the Genex watcher, not a full account connection: it can",
+    "  answer the in-game requests you approve and spend nothing.",
+    ""
+  ].join("\n"));
+  let warned = false;
+  const warnManual = () => {
+    if (warned) return;
+    warned = true;
+    log.dim("  (couldn't open a browser here \u2014 open the link above yourself)");
+  };
+  if (!open(started.verifyUrl, warnManual)) warnManual();
+  const deadline = Date.now() + waitMs;
+  let intervalMs = Math.max((started.interval || 2) * 1e3, MIN_POLL_INTERVAL_MS2);
+  let nextReassureAt = Date.now() + REASSURE_EVERY_MS2;
+  for (; ; ) {
+    let res;
+    try {
+      res = await apiFetch(`${apiUrl}/api/cli/device/poll`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ deviceCode: started.deviceCode })
+      }, { noTermsWait: true });
+    } catch {
+      res = new Response(null, { status: 599 });
+    }
+    if (res.status === 410) throw new Error("That code expired. Re-run `genex player install` for a fresh one.");
+    if (res.ok) {
+      const body = await res.json().catch(() => null);
+      if (body?.status === "approved" && body.token) {
+        if (body.scope !== void 0 && body.scope !== "player") {
+          throw new Error("This Genex server minted a full account credential instead of a player one \u2014 it is too old for the watcher. Update the stand, or run `genex player install` against one that is current.");
+        }
+        return {
+          token: bindToken(body.token, apiUrl),
+          expiresAt: body.expiresAt ?? new Date(Date.now() + 30 * 24 * 36e5).toISOString()
+        };
+      }
+      if (body?.status === "denied") throw new Error("That request was declined in the browser. Nothing was installed.");
+      if (body?.interval) intervalMs = Math.max(body.interval * 1e3, MIN_POLL_INTERVAL_MS2);
+    }
+    if (Date.now() + intervalMs > deadline) throw new Error(PLAYER_NOT_APPROVED);
+    if (Date.now() >= nextReassureAt) {
+      log.dim("  still waiting for you to approve\u2026");
+      nextReassureAt = Date.now() + REASSURE_EVERY_MS2;
+    }
+    await sleep4(intervalMs);
+  }
+}
+async function startPlayerDeviceAuth(apiUrl, label) {
+  const body = JSON.stringify({ ...label ? { label } : {}, scope: "player" });
+  for (let attempt = 0; attempt < 2; attempt++) {
+    const res = await apiFetch(`${apiUrl}/api/cli/device/start`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body
+    }, { noTermsWait: true });
+    if (res.status === 409) continue;
+    if (res.status === 404 || res.status === 501) {
+      throw new Error("This Genex server has no player sign-in \u2014 the watcher needs a current stand.");
+    }
+    if (!res.ok) throw new Error(`Couldn't start sign-in (HTTP ${res.status}). Check your connection and re-run this command.`);
+    return await res.json();
+  }
+  throw new Error("Couldn't start sign-in \u2014 please re-run this command.");
+}
+
+// src/lib/player/api.ts
+var PLAYER_VERSION_HEADER = "x-genex-player-version";
+var EXTERNAL_PROVIDER_HEADER = "X-Genex-External-Provider";
+var PlayerUpdateRequiredError = class extends Error {
+  minVersion;
+  latestVersion;
+  constructor(minVersion, latestVersion) {
+    super(`This watcher is below the server's floor (${minVersion}); the current version is ${latestVersion}.`);
+    this.name = "PlayerUpdateRequiredError";
+    this.minVersion = minVersion;
+    this.latestVersion = latestVersion;
+  }
+};
+var PlayerAuthError = class extends Error {
+  status;
+  code;
+  constructor(status2, code) {
+    super(`Genex refused this machine's credential (HTTP ${status2}${code ? `, ${code}` : ""}).`);
+    this.name = "PlayerAuthError";
+    this.status = status2;
+    this.code = code;
+  }
+};
+var PlayerApiError = class extends Error {
+  status;
+  code;
+  constructor(status2, code) {
+    super(`HTTP ${status2}${code ? ` ${code}` : ""}`);
+    this.name = "PlayerApiError";
+    this.status = status2;
+    this.code = code;
+  }
+};
+var PlayerClient = class {
+  apiUrl;
+  version;
+  token;
+  timeoutMs;
+  constructor(options) {
+    this.apiUrl = options.apiUrl;
+    this.token = options.token;
+    this.version = options.version ?? getCliVersion();
+    this.timeoutMs = options.timeoutMs ?? 3e4;
+  }
+  async call(path44, 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}`, {
+      ...init2,
+      headers,
+      signal: AbortSignal.timeout(this.timeoutMs)
+    }, { noTermsWait: true });
+    const body = await res.json().catch(() => null);
+    if (res.ok) return body ?? {};
+    const code = typeof body?.error === "string" ? body.error : "";
+    if (res.status === 426) {
+      throw new PlayerUpdateRequiredError(
+        typeof body?.minVersion === "string" ? body.minVersion : "unknown",
+        typeof body?.latestVersion === "string" ? body.latestVersion : "latest"
+      );
+    }
+    if (res.status === 401 || res.status === 403) throw new PlayerAuthError(res.status, code);
+    throw new PlayerApiError(res.status, code);
+  }
+  /** The versioned runner policy — read on start and refreshed periodically. */
+  async policy() {
+    return await this.call("/api/runtime/player/policy");
+  }
+  /** "I am here, this is what I can run." Also how a watcher learns its id. */
+  async heartbeat(input) {
+    return await this.call("/api/runtime/player/watchers/heartbeat", {
+      method: "POST",
+      body: JSON.stringify({
+        ...input.watcherId ? { watcherId: input.watcherId } : {},
+        version: this.version,
+        platform: input.platform,
+        runners: input.runners,
+        ...input.label ? { label: input.label } : {}
+      })
+    });
+  }
+  /** Everything this player has waiting on ONE funding lane. */
+  async pending(provider) {
+    const body = await this.call("/api/runtime/external/generations", {}, provider);
+    return Array.isArray(body.generations) ? body.generations : [];
+  }
+  /** Take a row for a bounded lease. Idempotent for the holder; 409 otherwise.
+   *  Answers with the job, so a runner needs no second read. */
+  async claim(id, provider, watcherId) {
+    return await this.call(`/api/runtime/external/generations/${encodeURIComponent(id)}/claim`, {
+      method: "POST",
+      body: JSON.stringify({ watcherId })
+    }, provider);
+  }
+  /** Hand a row back unfinished. `rate_limited` parks the budget behind it. */
+  async release(id, provider, input) {
+    return await this.call(`/api/runtime/external/generations/${encodeURIComponent(id)}/release`, {
+      method: "POST",
+      body: JSON.stringify({
+        watcherId: input.watcherId,
+        reason: input.reason,
+        ...input.retryAfterSeconds ? { retryAfterSeconds: Math.min(86400, Math.max(1, Math.round(input.retryAfterSeconds))) } : {}
+      })
+    }, provider);
+  }
+  /** The answer. `watcherId` names the lease holder — only it may submit. */
+  async submit(id, provider, watcherId, output) {
+    return await this.call(`/api/runtime/external/generations/${encodeURIComponent(id)}/result`, {
+      method: "POST",
+      body: JSON.stringify({ output, watcherId })
+    }, provider);
+  }
+};
+
+// src/lib/player/runners.ts
+import { spawn as spawn6, spawnSync } from "child_process";
+import fs36 from "fs/promises";
+import fsSync from "fs";
+import os9 from "os";
+import path40 from "path";
+import { randomUUID as randomUUID3 } from "crypto";
+var WATCHER_RUNNERS = ["claude", "codex"];
+var RUNNER_FOR_FAMILY = { claude: "claude", chatgpt: "codex" };
+var PROVIDER_FOR_RUNNER = { claude: "claude", codex: "chatgpt" };
+var FALLBACK_POLICY = {
+  version: "fallback",
+  minVersion: "0.0.0",
+  latestVersion: "0.0.0",
+  pollIntervalSeconds: 5,
+  backoff: { initialSeconds: 5, maxSeconds: 300, factor: 2, jitterRatio: 0.2 },
+  claude: { args: ["-p"], modelFlag: "--model" },
+  codex: { args: ["exec"], modelFlag: "--model" }
+};
+var CLAUDE_DENIED_TOOLS = [
+  "Bash",
+  "Edit",
+  "Write",
+  "Read",
+  "Glob",
+  "Grep",
+  "WebFetch",
+  "WebSearch",
+  "Task",
+  "NotebookEdit",
+  "TodoWrite",
+  "SlashCommand",
+  "KillShell",
+  "BashOutput"
+];
+var BYTES_PER_TOKEN = 4;
+var HARD_OUTPUT_BYTES = 2 * 1024 * 1024;
+var DEFAULT_TIMEOUT_MS = 10 * 6e4;
+function runnerBinaryEnv(runner) {
+  return `GENEX_PLAYER_${runner.toUpperCase()}_BIN`;
+}
+function runnerBinary(runner, env = process.env, platform = process.platform) {
+  const override = env[runnerBinaryEnv(runner)]?.trim();
+  if (override) {
+    try {
+      return fsSync.statSync(override).isFile() ? override : null;
+    } catch {
+      return null;
+    }
+  }
+  return resolveOnPath(runner, env, platform);
+}
+function detectRunners(env = process.env, platform = process.platform) {
+  const found = [];
+  for (const name of WATCHER_RUNNERS) if (runnerBinary(name, env, platform)) found.push(name);
+  return found;
+}
+function resolveOnPath(name, env = process.env, platform = process.platform) {
+  const win = platform === "win32";
+  const dirs = (env.PATH ?? env.Path ?? "").split(win ? ";" : ":").filter(Boolean);
+  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);
+      try {
+        const stat = fsSync.statSync(file);
+        if (!stat.isFile()) continue;
+        if (!win) fsSync.accessSync(file, fsSync.constants.X_OK);
+        return file;
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function names(args, ...flags) {
+  return args.some((a) => flags.includes(a) || flags.some((f) => a.startsWith(`${f}=`)));
+}
+function claudeArgv(job, policy = {}) {
+  const base = [...policy.args ?? ["-p"]];
+  const argv = [...base];
+  const add = (flag, value, ...aliases) => {
+    if (names(base, flag, ...aliases)) return;
+    argv.push(flag);
+    if (value !== void 0) argv.push(value);
+  };
+  if (!names(base, "-p", "--print")) argv.unshift("-p");
+  if (policy.modelFlag && !names(base, policy.modelFlag)) argv.push(policy.modelFlag, job.model.cliModel);
+  add("--output-format", "json");
+  const structured = job.outputFormat === "json" && job.schema !== void 0;
+  add("--max-turns", structured ? "2" : "1");
+  add("--no-session-persistence");
+  add("--permission-prompts", "none");
+  add("--strict-mcp-config");
+  argv.push("--append-system-prompt", job.system);
+  if (structured && !names(base, "--json-schema")) {
+    argv.push("--json-schema", JSON.stringify(job.schema));
+  }
+  if (!names(base, "--disallowedTools", "--disallowed-tools")) {
+    argv.push("--disallowedTools", ...CLAUDE_DENIED_TOOLS);
+  }
+  return argv;
+}
+function codexArgv(job, policy = {}, files) {
+  const base = [...policy.args ?? ["exec"]];
+  const argv = [...base];
+  const add = (flag, value) => {
+    if (names(base, flag)) return;
+    argv.push(flag);
+    if (value !== void 0) argv.push(value);
+  };
+  if (!names(base, "exec") && base[0] !== "exec") argv.unshift("exec");
+  add("--ephemeral");
+  add("--ignore-user-config");
+  add("--skip-git-repo-check");
+  add("--sandbox", "read-only");
+  add("-C", files.cwd);
+  if (files.schemaFile && !names(base, "--output-schema")) argv.push("--output-schema", files.schemaFile);
+  add("-o", files.outFile);
+  add("--color", "never");
+  if (policy.modelFlag && !names(base, policy.modelFlag)) argv.push(policy.modelFlag, job.model.cliModel);
+  argv.push("-");
+  return argv;
+}
+function classifyFailure(text) {
+  const t = text.toLowerCase();
+  if (/rate[ -]?limit|usage limit|quota|too many requests|429|\bresets?\b|limit reached/.test(t)) {
+    const retry = parseRetrySeconds(t);
+    return retry === void 0 ? { release: "rate_limited" } : { release: "rate_limited", retryAfterSeconds: retry };
+  }
+  if (/not logged in|please log ?in|\blogin\b|log in to|unauthorized|401|invalid api key|authentication (failed|required)|credentials/.test(t)) {
+    return { release: "auth_expired" };
+  }
+  if (/enoent|command not found|no such file or directory|is not recognized/.test(t)) {
+    return { release: "runner_unavailable" };
+  }
+  return { release: "failed" };
+}
+function parseRetrySeconds(text) {
+  const header = /retry[ -]after:?\s*(\d+)/.exec(text);
+  if (header?.[1]) return clampSeconds(Number(header[1]));
+  const phrase = /(?:try again|retry|resets?|wait|available again)\D{0,20}?(\d+)\s*(second|sec|minute|min|hour|hr)s?/.exec(text);
+  if (!phrase?.[1] || !phrase[2]) return void 0;
+  const n = Number(phrase[1]);
+  const unit = phrase[2];
+  const seconds = unit.startsWith("h") ? n * 3600 : unit.startsWith("m") ? n * 60 : n;
+  return clampSeconds(seconds);
+}
+function clampSeconds(value) {
+  if (!Number.isFinite(value) || value <= 0) return void 0;
+  return Math.min(86400, Math.max(1, Math.round(value)));
+}
+function outputByteCeiling(maxOutputTokens) {
+  const fromTokens = Math.max(1024, Math.round(maxOutputTokens * BYTES_PER_TOKEN));
+  return Math.min(HARD_OUTPUT_BYTES, fromTokens);
+}
+function parseClaudeEnvelope(stdout) {
+  const trimmed = stdout.trim();
+  if (!trimmed) return { ok: false, detail: "no_output" };
+  const start = trimmed.lastIndexOf("\n{");
+  const candidate = start >= 0 ? trimmed.slice(start + 1) : trimmed;
+  let body;
+  try {
+    body = JSON.parse(candidate);
+  } catch {
+    return { ok: false, detail: "unparseable_envelope", text: trimmed };
+  }
+  const text = typeof body.result === "string" ? body.result : void 0;
+  if (body.is_error === true || typeof body.subtype === "string" && body.subtype !== "success") {
+    return { ok: false, detail: typeof body.subtype === "string" ? body.subtype : "is_error", text };
+  }
+  const structured = body.structured_output;
+  return { ok: true, ...structured !== void 0 && structured !== null ? { result: structured } : {}, ...text !== void 0 ? { text } : {} };
+}
+function readOutput(value, job) {
+  if (value.result !== void 0) {
+    const size = Buffer.byteLength(JSON.stringify(value.result) ?? "");
+    if (size > outputByteCeiling(job.maxOutputTokens)) return { ok: false, detail: "output_too_large" };
+    return { ok: true, output: value.result };
+  }
+  const text = (value.text ?? "").trim();
+  if (!text) return { ok: false, detail: "empty_output" };
+  if (Buffer.byteLength(text) > outputByteCeiling(job.maxOutputTokens)) return { ok: false, detail: "output_too_large" };
+  if (job.outputFormat !== "json") return { ok: true, output: text };
+  const fenced = /^```(?:json)?\s*\n([\s\S]*?)\n```$/.exec(text);
+  try {
+    return { ok: true, output: JSON.parse(fenced?.[1] ?? text) };
+  } catch {
+    return { ok: false, detail: "output_not_json" };
+  }
+}
+function killRunner(child, platform = process.platform, killTreeFn) {
+  const pid = child.pid;
+  if (typeof pid !== "number") return;
+  if (platform === "win32") {
+    try {
+      if (killTreeFn) killTreeFn(pid);
+      else {
+        const done = spawnSync("taskkill", ["/pid", String(pid), "/T", "/F"], { windowsHide: true });
+        if (done.error || done.status !== 0) child.kill("SIGKILL");
+      }
+    } catch {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+    }
+    return;
+  }
+  try {
+    process.kill(-pid, "SIGKILL");
+  } catch {
+  }
+}
+async function runJob(job, options = {}) {
+  const started = Date.now();
+  const policy = options.policy ?? FALLBACK_POLICY;
+  const runner = RUNNER_FOR_FAMILY[job.model.family];
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const log = options.log ?? (() => {
+  });
+  const spawnFn = options.spawnFn ?? spawn6;
+  const platform = options.platform ?? process.platform;
+  const resolved = options.binary ?? runnerBinary(runner);
+  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");
+  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 });
+    }
+    argv = codexArgv(job, policy.codex ?? FALLBACK_POLICY.codex ?? {}, { cwd, outFile, ...schemaFile ? { schemaFile } : {} });
+  }
+  log(`  ${runner} ${job.model.cliModel} (no tools)`);
+  try {
+    const child = spawnFn(resolved, argv, {
+      cwd,
+      stdio: ["pipe", "pipe", "pipe"],
+      // The player's own environment, minus anything that would redirect the
+      // binary off their subscription and onto a billed API account.
+      env: {
+        ...process.env,
+        ANTHROPIC_API_KEY: void 0,
+        ANTHROPIC_AUTH_TOKEN: void 0,
+        ANTHROPIC_BASE_URL: void 0,
+        OPENAI_API_KEY: void 0,
+        OPENAI_BASE_URL: void 0
+      },
+      // A killable process GROUP on POSIX. On Windows it buys nothing — there
+      // are no groups — and `killRunner` uses taskkill there instead.
+      detached: platform !== "win32"
+    });
+    child.stdin?.end(job.user);
+    const out = [];
+    const err = [];
+    child.stdout?.on("data", (d) => out.push(d.toString()));
+    child.stderr?.on("data", (d) => err.push(d.toString()));
+    const kill = () => killRunner(child, platform, options.killTreeFn);
+    const code = await new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        kill();
+        resolve(null);
+      }, timeoutMs);
+      const onAbort = () => {
+        kill();
+        resolve("aborted");
+      };
+      options.signal?.addEventListener("abort", onAbort, { once: true });
+      const done = (value) => {
+        clearTimeout(timer);
+        options.signal?.removeEventListener("abort", onAbort);
+        resolve(value);
+      };
+      child.once("error", () => done("spawn-failed"));
+      child.once("close", (c2) => done(c2));
+    });
+    const durationMs = Date.now() - started;
+    if (code === "spawn-failed") return { ok: false, release: "runner_unavailable", detail: `missing:${runner}`, durationMs };
+    if (code === "aborted") return { ok: false, release: "runner_unavailable", detail: "shutdown", exitCode: null, durationMs };
+    if (code === null) return { ok: false, release: "failed", detail: "timeout", exitCode: null, durationMs };
+    const stderrText = err.join("");
+    if (runner === "claude") {
+      const envelope = parseClaudeEnvelope(out.join(""));
+      if (!envelope.ok) {
+        const classified = classifyFailure(`${envelope.detail ?? ""} ${envelope.text ?? ""} ${stderrText}`);
+        return { ok: false, ...classified, detail: envelope.detail ?? "failed", exitCode: code, durationMs };
+      }
+      const read2 = readOutput(envelope, job);
+      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(() => "");
+    if (code !== 0 && !text.trim()) {
+      const classified = classifyFailure(`${stderrText} exit ${code}`);
+      return { ok: false, ...classified, detail: `exit_${code}`, exitCode: code, durationMs };
+    }
+    const read = readOutput({ text }, job);
+    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(() => {
+    });
+  }
+}
+
+// src/lib/player/service.ts
+import fs37 from "fs/promises";
+import os10 from "os";
+import path41 from "path";
+import { execFile } from "child_process";
+import { promisify } from "util";
+var run2 = promisify(execFile);
+var SERVICE_LABEL = "games.genex.player";
+var SYSTEMD_UNIT = "genex-player.service";
+var PLAYER_AUTOSTART_SPEC = "@genex-ai/cli-demo@latest";
+var SUPERVISED_ENV = "GENEX_PLAYER_SUPERVISED";
+function supervisedWatcher(env = process.env) {
+  return env[SUPERVISED_ENV] === "1";
+}
+function servicePlatform(platform = process.platform) {
+  if (platform === "darwin" || platform === "win32") return platform;
+  return "linux";
+}
+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") };
+}
+function xmlEscape(value) {
+  return value.replace(/[<>&'"]/g, (ch) => ({ "<": "&lt;", ">": "&gt;", "&": "&amp;", "'": "&apos;", '"': "&quot;" })[ch]);
+}
+function unitFile(platform, input, paths) {
+  if (platform === "darwin") {
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${SERVICE_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+${[input.launcher, ...input.args].map((a) => `    <string>${xmlEscape(a)}</string>`).join("\n")}
+  </array>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key><string>${xmlEscape(input.pathEnv)}</string>
+    <key>HOME</key><string>${xmlEscape(input.home)}</string>
+    <!-- Tells the watcher a supervisor started it, so an update is taken by
+         stopping (exit 1, restarted below, resolving @latest again) rather
+         than by spawning a detached grandchild: the parent's exit IS this
+         job's exit, and that grandchild would have run unsupervised. -->
+    <key>${SUPERVISED_ENV}</key><string>1</string>
+  </dict>
+  <key>RunAtLoad</key><true/>
+  <!-- KeepAlive, but NOT unconditionally: exit 0 means the watcher decided to
+       stop (a signal, or a credential only a person with a browser can
+       replace), and restarting that every 30 seconds is an invisible loop on
+       somebody else's machine. A crash comes back \u2014 and so does an update,
+       which exits non-zero on purpose and is bounded by the relaunch cooldown. -->
+  <key>KeepAlive</key>
+  <dict><key>SuccessfulExit</key><false/></dict>
+  <key>ThrottleInterval</key><integer>30</integer>
+  <key>StandardOutPath</key><string>${xmlEscape(paths.log)}</string>
+  <key>StandardErrorPath</key><string>${xmlEscape(paths.errorLog)}</string>
+</dict>
+</plist>
+`;
+  }
+  if (platform === "linux") {
+    return `[Unit]
+Description=Genex player watcher \u2014 answer the in-game requests you approved, on your own subscription
+After=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${[input.launcher, ...input.args].map((a) => JSON.stringify(a)).join(" ")}
+Environment=PATH=${input.pathEnv}
+Environment=HOME=${input.home}
+# The supervisor marker: an update is taken by stopping and letting this unit
+# start the current version, never by spawning a child systemd is not watching.
+Environment=${SUPERVISED_ENV}=1
+# on-failure rather than always, for the reason spelled out in the plist above:
+# a clean exit is a decision (signal, dead credential) and must stay stopped; a
+# crash comes back, and so does an update, which exits non-zero on purpose.
+Restart=on-failure
+RestartSec=30
+StandardOutput=append:${paths.log}
+StandardError=append:${paths.errorLog}
+
+[Install]
+WantedBy=default.target
+`;
+  }
+  return `@echo off\r
+set "PATH=${input.pathEnv}"\r
+start "" /b "${input.launcher}" ${input.args.map((a) => `"${a}"`).join(" ")} >> "${paths.log}" 2>> "${paths.errorLog}"\r
+`;
+}
+function autostartCommand(opts) {
+  const npx = resolveOnPath("npx");
+  const tail = ["player", "run", ...opts.apiUrl ? ["--api-url", opts.apiUrl] : []];
+  if (npx) return { launcher: npx, args: ["-y", PLAYER_AUTOSTART_SPEC, ...tail], fallback: false };
+  return { launcher: process.execPath, args: [process.argv[1] ?? "", ...tail], fallback: true };
+}
+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 });
+  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}`;
+    await run2("launchctl", ["bootout", domain, paths.unit]).catch(() => {
+    });
+    try {
+      await run2("launchctl", ["bootstrap", domain, paths.unit]);
+    } catch (error) {
+      return { unit: paths.unit, loaded: false, detail: `launchctl refused it: ${String(error.message).split("\n")[0]}` };
+    }
+    const printed2 = await run2("launchctl", ["print", `${domain}/${SERVICE_LABEL}`]).then((r) => r.stdout).catch(() => "");
+    return { unit: paths.unit, loaded: printed2.includes(SERVICE_LABEL), detail: printed2.includes("state = running") ? "running" : "registered" };
+  }
+  if (platform === "linux") {
+    await run2("systemctl", ["--user", "daemon-reload"]).catch(() => {
+    });
+    try {
+      await run2("systemctl", ["--user", "enable", "--now", SYSTEMD_UNIT]);
+    } catch (error) {
+      return { unit: paths.unit, loaded: false, detail: `systemctl refused it: ${String(error.message).split("\n")[0]}` };
+    }
+    const active = await run2("systemctl", ["--user", "is-active", SYSTEMD_UNIT]).then((r) => r.stdout.trim()).catch(() => "unknown");
+    return { unit: paths.unit, loaded: active === "active", detail: active };
+  }
+  return { unit: paths.unit, loaded: true, detail: "starts at your next sign-in" };
+}
+async function serviceInstalled(home = os10.homedir(), platform = servicePlatform()) {
+  const paths = servicePaths(platform, home);
+  return await fs37.stat(paths.unit).then(() => paths.unit, () => null);
+}
+async function stopService(home = os10.homedir(), platform = servicePlatform()) {
+  const paths = servicePaths(platform, home);
+  const present = await serviceInstalled(home, platform);
+  if (playerDryRun()) return { unit: paths.unit, loaded: false, detail: present ? "dry run \u2014 the system was not asked" : "nothing installed" };
+  if (platform === "darwin") {
+    const out2 = await run2("launchctl", ["bootout", `gui/${process.getuid?.() ?? 501}`, paths.unit]).then(() => "stopped").catch(() => "was not running");
+    return { unit: paths.unit, loaded: false, detail: out2 };
+  }
+  if (platform === "linux") {
+    const out2 = await run2("systemctl", ["--user", "stop", SYSTEMD_UNIT]).then(() => "stopped").catch(() => "was not running");
+    return { unit: paths.unit, loaded: false, detail: out2 };
+  }
+  const out = await run2("taskkill", ["/IM", "genex-player.cmd", "/F"]).then(() => "stopped").catch(() => "was not running");
+  return { unit: paths.unit, loaded: false, detail: out };
+}
+async function uninstallService(home = os10.homedir(), platform = servicePlatform()) {
+  const paths = servicePaths(platform, home);
+  const present = await serviceInstalled(home, platform);
+  if (!playerDryRun()) {
+    if (platform === "darwin") await run2("launchctl", ["bootout", `gui/${process.getuid?.() ?? 501}`, paths.unit]).catch(() => {
+    });
+    if (platform === "linux") {
+      await run2("systemctl", ["--user", "disable", "--now", SYSTEMD_UNIT]).catch(() => {
+      });
+      await run2("systemctl", ["--user", "daemon-reload"]).catch(() => {
+      });
+    }
+  }
+  await fs37.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 fsSync2 from "fs";
+import path42 from "path";
+import { spawn as spawn7 } from "child_process";
+var RELAUNCH_COOLDOWN_MS = 10 * 60 * 1e3;
+function relaunchPlan(input) {
+  const base = autostartCommand({ ...input.apiUrl ? { apiUrl: input.apiUrl } : {} });
+  if (base.fallback) {
+    return { launcher: base.launcher, args: base.args };
+  }
+  const spec = input.version && input.version !== "latest" ? `@genex-ai/cli-demo@${input.version}` : PLAYER_AUTOSTART_SPEC;
+  const sub = input.sub ?? "run";
+  return {
+    launcher: base.launcher,
+    args: [
+      "-y",
+      spec,
+      "player",
+      sub,
+      "--relaunched",
+      ...input.extraArgs ?? [],
+      ...input.apiUrl ? ["--api-url", input.apiUrl] : []
+    ]
+  };
+}
+function relaunchPossible() {
+  return !autostartCommand({}).fallback;
+}
+async function relaunchOnCooldown(home, now = Date.now()) {
+  try {
+    const raw = await fs38.readFile(playerPaths(home).relaunch, "utf8");
+    const at = Date.parse(JSON.parse(raw).at ?? "");
+    return Number.isFinite(at) && now - at < RELAUNCH_COOLDOWN_MS;
+  } catch {
+    return false;
+  }
+}
+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 });
+  } catch {
+  }
+}
+async function relaunchWatcher(input) {
+  const plan = relaunchPlan(input);
+  const log = input.log ?? (() => {
+  });
+  if (input.relaunched) return { launched: false, plan, reason: "relaunched_child" };
+  if (!relaunchPossible()) return { launched: false, plan, reason: "no_npx" };
+  if (await relaunchOnCooldown(input.home)) return { launched: false, plan, reason: "cooldown" };
+  await markRelaunch(input.version, input.home);
+  if (supervisedWatcher()) {
+    log(`player: stopping so the login item restarts as ${input.version} (it resolves ${PLAYER_AUTOSTART_SPEC} each start)`);
+    return { launched: false, plan, reason: "supervisor_restarts" };
+  }
+  if (playerDryRun()) {
+    log(`player: would relaunch: ${JSON.stringify([plan.launcher, ...plan.args])}`);
+    return { launched: true, plan, reason: "dry_run" };
+  }
+  let out;
+  let err;
+  const paths = playerPaths(input.home);
+  try {
+    await fs38.mkdir(paths.logDir, { recursive: true, mode: 448 });
+    out = fsSync2.openSync(paths.log, "a", 384);
+    err = fsSync2.openSync(paths.errorLog, "a", 384);
+  } catch {
+  }
+  try {
+    const child = spawn7(plan.launcher, plan.args, {
+      detached: true,
+      stdio: ["ignore", out ?? "ignore", err ?? "ignore"]
+    });
+    child.on("error", (reason) => log(`player: relaunch could not start (${reason.message})`));
+    child.unref();
+  } finally {
+    for (const fd of [out, err]) if (fd !== void 0) try {
+      fsSync2.closeSync(fd);
+    } catch {
+    }
+  }
+  log(`player: relaunching as ${input.version}`);
+  return { launched: true, plan };
+}
+
+// src/lib/player/loop.ts
+import os11 from "os";
+var POLICY_REFRESH_MS = 5 * 6e4;
+var MAX_HEARTBEAT_MS = 6e4;
+var LEASE_RENEW_MS = 45e3;
+var JOB_TIMEOUT_MS = 10 * 6e4;
+var SHUTDOWN_RETRY_SECONDS = 5;
+var MAX_PROVIDER_COOLDOWN_MS = 60 * 6e4;
+var sleep5 = (ms) => new Promise((r) => setTimeout(r, ms));
+function platformTag(platform = process.platform) {
+  return platform.toLowerCase().replace(/[^a-z0-9_-]/g, "").slice(0, 40) || "unknown";
+}
+function backoffMs(policy, attempt, random = Math.random) {
+  const b = policy.backoff ?? FALLBACK_POLICY.backoff;
+  const raw = Math.min(b.maxSeconds, b.initialSeconds * Math.pow(b.factor, Math.max(0, attempt - 1)));
+  const jitter = 1 + (random() * 2 - 1) * b.jitterRatio;
+  return Math.max(1e3, Math.round(raw * jitter * 1e3));
+}
+function isNewer(a, b) {
+  const pa = /^(\d+)\.(\d+)\.(\d+)/.exec(a);
+  const pb = /^(\d+)\.(\d+)\.(\d+)/.exec(b);
+  if (!pa || !pb) return false;
+  for (let i = 1; i <= 3; i++) {
+    const x = Number(pa[i]);
+    const y = Number(pb[i]);
+    if (x !== y) return x > y;
+  }
+  return false;
+}
+function workable(row, watcherId, now = Date.now()) {
+  if (!row.runner) return false;
+  if (!row.claimedBy || row.claimedBy === watcherId) return true;
+  const until = Date.parse(row.leaseExpiresAt ?? "");
+  return Number.isFinite(until) && until <= now;
+}
+async function runWatcherLoop(options) {
+  const { client, install: install2, log } = options;
+  const runJobFn = options.runJobFn ?? runJob;
+  const keepGoing = options.keepGoing ?? (() => true);
+  const relaunchReady = options.relaunchReady ?? (() => true);
+  const label = install2.label;
+  let policy = FALLBACK_POLICY;
+  let runners = detectRunners();
+  let watcherId = install2.watcherId ?? "";
+  let policyAt = 0;
+  let heartbeatAt = 0;
+  let failures = 0;
+  let warnedNoRunners = false;
+  let warnedStuckVersion = false;
+  let stop2 = null;
+  const held = { row: null };
+  const cooldown = /* @__PURE__ */ new Map();
+  const state = {
+    v: 1,
+    pid: process.pid,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lastHeartbeatAt: null,
+    lastPollAt: null,
+    lastJobAt: null,
+    watcherId: watcherId || null,
+    policyVersion: null,
+    runners,
+    jobsCompleted: 0,
+    jobsReleased: 0,
+    lastError: null
+  };
+  const shutdown = new AbortController();
+  const onSignal = (signal) => {
+    if (stop2) return;
+    stop2 = { kind: "signal", signal };
+    shutdown.abort();
+    log(`player: ${signal} \u2014 handing back anything in flight`);
+  };
+  const sigint = () => onSignal("SIGINT");
+  const sigterm = () => onSignal("SIGTERM");
+  process.on("SIGINT", sigint);
+  process.on("SIGTERM", sigterm);
+  try {
+    for (; ; ) {
+      if (stop2 || !keepGoing()) break;
+      const now = Date.now();
+      if (now >= policyAt) {
+        try {
+          policy = await client.policy();
+          policyAt = now + POLICY_REFRESH_MS;
+          state.policyVersion = policy.version ?? null;
+          runners = detectRunners();
+          state.runners = runners;
+          warnedNoRunners = false;
+          failures = 0;
+        } catch (error) {
+          const fatal = classifyFatal(error);
+          if (fatal) {
+            stop2 = fatal;
+            break;
+          }
+          failures += 1;
+          policyAt = now + POLICY_REFRESH_MS;
+          log(`player: policy unreadable (${describe(error)}); using the built-in one`);
+        }
+      }
+      if (now >= heartbeatAt) {
+        try {
+          const beat = await client.heartbeat({
+            ...watcherId ? { watcherId } : {},
+            platform: platformTag(),
+            runners,
+            ...label ? { label } : {}
+          });
+          watcherId = beat.watcherId;
+          state.watcherId = watcherId;
+          state.lastHeartbeatAt = (/* @__PURE__ */ new Date()).toISOString();
+          state.policyVersion = beat.policyVersion ?? state.policyVersion;
+          heartbeatAt = now + Math.min(MAX_HEARTBEAT_MS, Math.max(5e3, (beat.pollIntervalSeconds || 5) * 1e3 * 6));
+          failures = 0;
+          if (isNewer(beat.latestVersion, client.version)) {
+            if (await relaunchReady(beat.latestVersion)) {
+              stop2 = { kind: "update_available", latestVersion: beat.latestVersion };
+              break;
+            }
+            if (!warnedStuckVersion) {
+              warnedStuckVersion = true;
+              log(`player: ${beat.latestVersion} is current and this is ${client.version}, but nothing here can fetch it \u2014 still answering`);
+            }
+          }
+        } catch (error) {
+          const fatal = classifyFatal(error);
+          if (fatal) {
+            stop2 = fatal;
+            break;
+          }
+          failures += 1;
+          state.lastError = describe(error);
+          heartbeatAt = now + backoffMs(policy, failures);
+          log(`player: heartbeat failed (${describe(error)})`);
+          await sleep5(backoffMs(policy, failures));
+          continue;
+        }
+      }
+      const providers = [...new Set(runners.map((r) => PROVIDER_FOR_RUNNER[r]))];
+      if (providers.length === 0 && !warnedNoRunners) {
+        warnedNoRunners = true;
+        log("player: no claude or codex binary here \u2014 nothing can be answered yet");
+      }
+      let worked = false;
+      for (const provider of providers) {
+        if (stop2) break;
+        const until = cooldown.get(provider) ?? 0;
+        if (until > Date.now()) continue;
+        if (until) cooldown.delete(provider);
+        let pending;
+        try {
+          pending = await client.pending(provider);
+          state.lastPollAt = (/* @__PURE__ */ new Date()).toISOString();
+          failures = 0;
+        } catch (error) {
+          const fatal = classifyFatal(error);
+          if (fatal) {
+            stop2 = fatal;
+            break;
+          }
+          failures += 1;
+          state.lastError = describe(error);
+          log(`player: poll failed (${describe(error)})`);
+          await sleep5(backoffMs(policy, failures));
+          continue;
+        }
+        for (const row of pending) {
+          if (stop2) break;
+          if (!workable(row, watcherId)) continue;
+          if (await handleOne(row, provider)) worked = true;
+          break;
+        }
+      }
+      if (stop2) break;
+      await writePlayerState(state, options.home);
+      if (options.once) {
+        stop2 = { kind: "once" };
+        break;
+      }
+      const interval = options.pollIntervalMsOverride ?? Math.max(1e3, (policy.pollIntervalSeconds || 5) * 1e3);
+      if (!worked) await sleep5(interval);
+    }
+  } finally {
+    process.off("SIGINT", sigint);
+    process.off("SIGTERM", sigterm);
+    const stranded = held.row;
+    if (stranded && watcherId) {
+      await client.release(stranded.id, stranded.provider, {
+        watcherId,
+        reason: "runner_unavailable",
+        retryAfterSeconds: SHUTDOWN_RETRY_SECONDS
+      }).catch(() => {
+      });
+      held.row = null;
+      state.jobsReleased += 1;
+      log(`player: released ${stranded.id} (shutdown)`);
+    }
+    await writePlayerState(state, options.home);
+  }
+  return { stop: stop2 ?? { kind: "once" }, state };
+  async function handleOne(row, provider) {
+    const job = row.runner;
+    let claimed;
+    try {
+      claimed = await client.claim(row.id, provider, watcherId);
+    } catch (error) {
+      if (error instanceof PlayerApiError && (error.code === "already_claimed" || error.code === "external_request_not_pending")) {
+        log(`player: ${row.id} taken by another machine`);
+        return false;
+      }
+      const fatal = classifyFatal(error);
+      if (fatal) {
+        stop2 = fatal;
+        return false;
+      }
+      failures += 1;
+      log(`player: could not claim ${row.id} (${describe(error)})`);
+      await sleep5(backoffMs(policy, failures));
+      return false;
+    }
+    held.row = { id: row.id, provider };
+    const live = claimed.runner ?? job;
+    const renew = setInterval(() => {
+      void client.claim(row.id, provider, watcherId).catch(() => {
+      });
+    }, LEASE_RENEW_MS);
+    renew.unref?.();
+    log(`player: ${row.id} ${live.mode} ${live.model.cliModel} running`);
+    let outcome2;
+    try {
+      outcome2 = await runJobFn(live, {
+        policy,
+        timeoutMs: Math.min(JOB_TIMEOUT_MS, Math.max(3e4, (live.leaseSeconds || 120) * 1e3 * 5)),
+        signal: shutdown.signal,
+        log
+      });
+    } finally {
+      clearInterval(renew);
+    }
+    state.lastJobAt = (/* @__PURE__ */ new Date()).toISOString();
+    const shuttingDown = stop2 !== null;
+    if (!outcome2.ok || shuttingDown) {
+      const reason = shuttingDown ? "runner_unavailable" : outcome2.release ?? "failed";
+      const retryAfterSeconds = shuttingDown ? SHUTDOWN_RETRY_SECONDS : outcome2.retryAfterSeconds ?? (reason === "rate_limited" ? (policy.backoff ?? FALLBACK_POLICY.backoff).maxSeconds : void 0);
+      state.jobsReleased += 1;
+      state.lastError = reason;
+      try {
+        await client.release(row.id, provider, { watcherId, reason, ...retryAfterSeconds ? { retryAfterSeconds } : {} });
+        held.row = null;
+      } catch (error) {
+        const fatal = classifyFatal(error);
+        if (fatal) {
+          stop2 = fatal;
+          held.row = null;
+          return true;
+        }
+        log(`player: release of ${row.id} failed (${describe(error)})`);
+      }
+      log(`player: ${row.id} released ${reason}${outcome2.detail ? ` (${outcome2.detail})` : ""} after ${outcome2.durationMs}ms`);
+      if (reason === "rate_limited" || reason === "auth_expired") {
+        const waitMs = Math.min(MAX_PROVIDER_COOLDOWN_MS, Math.max(
+          1e3,
+          (retryAfterSeconds ?? (policy.backoff ?? FALLBACK_POLICY.backoff).maxSeconds) * 1e3
+        ));
+        cooldown.set(provider, Date.now() + waitMs);
+        log(`player: ${provider} waits ${Math.round(waitMs / 1e3)}s before the next request`);
+      }
+      if (reason === "auth_expired") {
+        const binary = live.model.family === "claude" ? "claude" : "codex";
+        log(`player: your ${binary} CLI is not signed in \u2014 run \`${binary} login\` on this machine`);
+      }
+      return true;
+    }
+    try {
+      const receipt = await client.submit(row.id, provider, watcherId, outcome2.output);
+      held.row = null;
+      state.jobsCompleted += 1;
+      log(`player: ${row.id} delivered in ${outcome2.durationMs}ms (${receipt.status})`);
+    } catch (error) {
+      const fatal = classifyFatal(error);
+      if (fatal) {
+        stop2 = fatal;
+        return true;
+      }
+      state.lastError = describe(error);
+      log(`player: ${row.id} could not be submitted (${describe(error)})`);
+      await client.release(row.id, provider, { watcherId, reason: "failed" }).catch(() => {
+      });
+      held.row = null;
+      state.jobsReleased += 1;
+    }
+    return true;
+  }
+}
+function classifyFatal(error) {
+  if (error instanceof PlayerUpdateRequiredError) {
+    return { kind: "update_required", minVersion: error.minVersion, latestVersion: error.latestVersion };
+  }
+  if (error instanceof PlayerAuthError) return { kind: "auth", status: error.status, code: error.code };
+  return null;
+}
+function describe(error) {
+  if (error instanceof PlayerApiError) return `${error.status}${error.code ? ` ${error.code}` : ""}`;
+  if (error instanceof Error) return error.name === "TimeoutError" ? "timeout" : error.name;
+  return "error";
+}
+function defaultLabel2() {
+  try {
+    return os11.hostname().replace(/[^\w .@-]/g, "").trim().slice(0, 64) || "This machine";
+  } catch {
+    return "This machine";
+  }
+}
+
+// src/commands/player.ts
+var SUBS4 = ["install", "run", "status", "stop", "uninstall"];
+var PLAYER_NOT_INSTALLED = "This machine is not set up to answer in-game model requests \u2014 run `genex player install` first.";
+var PLAYER_REAUTH_REQUIRED = "Genex no longer accepts this machine's approval \u2014 run `genex player install` again.";
+var PLAYER_NO_RUNNERS = "Neither `claude` nor `codex` is on this machine's PATH, so nothing can be answered yet. Install the one whose subscription you pay for, sign into it, and this watcher picks it up on its own.";
+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(", ")}.`);
+    return;
+  }
+  if (opts.dryRun) process.env[PLAYER_DRY_RUN_ENV] = "1";
+  if (sub === "install") return await install(opts, log);
+  if (sub === "run") return await run3(opts, log);
+  if (sub === "status") return await status(opts, log);
+  if (sub === "stop") return await stop(opts, log);
+  return await uninstall(opts, log);
+}
+async function install(opts, log) {
+  const apiUrl = normalizeApiOrigin(getApiUrl(opts.apiUrl));
+  const label = opts.playerLabel?.trim() || defaultLabel2();
+  let approval;
+  try {
+    approval = await authorizePlayer(apiUrl, {
+      log,
+      label,
+      ...opts.timeoutSec ? { waitMs: opts.timeoutSec * 1e3 } : {}
+    });
+  } catch (error) {
+    fail3(opts, log, "player install", error instanceof Error ? error.message : String(error));
+    return;
+  }
+  let record = {
+    v: 1,
+    apiUrl,
+    token: approval.token,
+    expiresAt: approval.expiresAt,
+    label,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    version: getCliVersion()
+  };
+  const credentialFile = await writePlayerInstall(record);
+  const runners = detectRunners();
+  const client = new PlayerClient({ apiUrl, token: approval.token });
+  try {
+    const beat = await client.heartbeat({ platform: platformTag(), runners, label });
+    record = { ...record, watcherId: beat.watcherId };
+    await writePlayerInstall(record);
+  } catch (error) {
+    if (error instanceof PlayerUpdateRequiredError) {
+      const outcome2 = await relaunchWatcher({
+        version: error.latestVersion,
+        apiUrl,
+        sub: "install",
+        // The flags the refused install carried, so the newer one finishes
+        // the same install rather than a default one.
+        extraArgs: [
+          ...opts.playerLabel ? ["--label", opts.playerLabel] : [],
+          ...opts.noAutostart ? ["--no-autostart"] : []
+        ],
+        relaunched: Boolean(opts.relaunched),
+        log: (line) => log.plain(line)
+      });
+      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 });
+        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)}).`);
+    return;
+  }
+  const platform = servicePlatform();
+  const paths = servicePaths(platform);
+  let unit = null;
+  let unitDetail = "not installed (--no-autostart)";
+  let supervised = false;
+  if (!opts.noAutostart) {
+    const command = autostartCommand({ ...usesNonDefaultStand(opts, apiUrl) ? { apiUrl } : {} });
+    const result = await installService({
+      launcher: command.launcher,
+      args: command.args,
+      // See lib/player/service.ts: a login agent inherits almost no PATH, and
+      // this program exists to run binaries that are rarely on the default one.
+      pathEnv: process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin",
+      home: os12.homedir()
+    }, platform);
+    unit = result.unit;
+    unitDetail = result.detail;
+    supervised = result.loaded;
+    if (command.fallback) {
+      log.warn("No `npx` on this machine's PATH, so the login entry runs THIS copy of the CLI and will not update itself.");
+    }
+  }
+  let started = supervised;
+  if (!started && !playerDryRun()) started = await spawnDetachedRun(apiUrl, opts);
+  if (opts.json) {
+    writeJsonLine2({
+      command: "player install",
+      status: "ok",
+      error: null,
+      ...describeInstall(record),
+      runners,
+      credentialFile,
+      autostart: unit,
+      autostartDetail: unitDetail,
+      running: started,
+      log: paths.log
+    });
+    return;
+  }
+  log.plain("");
+  log.success(`This machine can now answer the in-game model requests you approve, on your own subscription.`);
+  log.plain("");
+  log.plain(oneParagraph({ record, runners, unit, unitDetail, started, logFile: paths.log, credentialFile }));
+  if (runners.length === 0) log.warn(PLAYER_NO_RUNNERS);
+}
+function oneParagraph(input) {
+  const runnerText = input.runners.length === 0 ? "no runner yet" : input.runners.map((r) => r === "claude" ? "Claude Code" : "Codex").join(" and ");
+  return [
+    `  Genex approval  stored in ${input.credentialFile} (only this machine can read it). It can`,
+    "                  answer approved requests and spend nothing \u2014 no coins, no credits, no",
+    "                  account changes. Your Claude or ChatGPT sign-in is never read, copied or",
+    "                  sent anywhere; the watcher only starts the official CLI you already use.",
+    `  Runners         ${runnerText}`,
+    input.unit ? `  Starts at login ${input.unit} (${input.unitDetail})` : "  Starts at login no \u2014 run `genex player run` yourself",
+    `  Running now     ${input.started ? "yes" : "no \u2014 start it with `genex player run`"}`,
+    `  Log             ${input.logFile} (ids and timings only, never what a game asked for)`,
+    "  Stop it         genex player stop        \xB7  and for good: genex player uninstall",
+    "",
+    "  You never need to paste anything again: approve a request in a game and the answer",
+    "  comes back on its own. Revoke this machine any time from your Genex dashboard."
+  ].join("\n");
+}
+async function spawnDetachedRun(apiUrl, opts) {
+  let out;
+  let err;
+  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);
+    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", () => {
+    });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  } finally {
+    for (const fd of [out, err]) if (fd !== void 0) try {
+      fs39.closeSync(fd);
+    } catch {
+    }
+  }
+}
+function usesNonDefaultStand(opts, apiUrl) {
+  return apiUrl !== normalizeApiOrigin(getApiUrl()) || Boolean(opts.apiUrl);
+}
+async function run3(opts, log) {
+  const record = await readPlayerInstall();
+  if (!record) {
+    fail3(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.`);
+    return;
+  }
+  const apiUrl = opts.apiUrl ? normalizeApiOrigin(getApiUrl(opts.apiUrl)) : record.apiUrl;
+  bindToken(record.token, apiUrl);
+  const client = new PlayerClient({ apiUrl, token: record.token });
+  const line = (text) => {
+    process.stdout.write(`${(/* @__PURE__ */ new Date()).toISOString()} ${text}
+`);
+  };
+  if (opts.foreground) {
+    log.plain(c.bold("genex player run"));
+    log.dim(`  ${apiUrl}  \xB7  watcher ${record.watcherId ?? "(unregistered)"}  \xB7  v${getCliVersion()}`);
+    log.dim("  Approve a request in a game and it runs here. Ctrl-C to stop.");
+  }
+  const result = await runWatcherLoop({
+    install: record,
+    client,
+    ...opts.once ? { once: true } : {},
+    log: line,
+    // Only break off answering requests for a merely AVAILABLE update when a
+    // relaunch will actually follow. A person watching a foreground run is
+    // told about it instead — their terminal is not a thing to restart behind
+    // their back.
+    relaunchReady: async () => !opts.foreground && !opts.relaunched && relaunchPossible() && !await relaunchOnCooldown()
+  });
+  if (result.state.watcherId && result.state.watcherId !== record.watcherId) {
+    await writePlayerInstall({ ...record, watcherId: result.state.watcherId }).catch(() => {
+    });
+  }
+  const stop2 = result.stop;
+  if (stop2.kind === "update_required" || stop2.kind === "update_available") {
+    const version = stop2.kind === "update_required" ? stop2.latestVersion : stop2.latestVersion;
+    if (opts.foreground) {
+      line(`player: version ${version} is current; this is ${getCliVersion()} \u2014 restart with npx -y @genex-ai/cli-demo@latest player run`);
+      return;
+    }
+    const outcome2 = await relaunchWatcher({
+      version,
+      apiUrl,
+      sub: "run",
+      relaunched: Boolean(opts.relaunched),
+      log: line
+    });
+    if (outcome2.reason === "supervisor_restarts") {
+      process.exitCode = 1;
+      return;
+    }
+    if (!outcome2.launched) line(`player: not relaunching (${outcome2.reason ?? "unknown"}) \u2014 still ${getCliVersion()}, current is ${version}`);
+    return;
+  }
+  if (stop2.kind === "auth") {
+    line(`player: ${PLAYER_REAUTH_REQUIRED}`);
+    if (opts.foreground) process.exitCode = 1;
+    return;
+  }
+  if (stop2.kind === "signal") line("player: stopped");
+}
+async function status(opts, log) {
+  const record = await readPlayerInstall();
+  const state = await readPlayerState();
+  const runners = detectRunners();
+  const platform = servicePlatform();
+  const unit = await serviceInstalled(os12.homedir(), platform);
+  const paths = playerPaths();
+  const running = state?.pid ? pidAlive(state.pid) : null;
+  const server = { reachable: false, policyVersion: null, minVersion: null, latestVersion: null, pending: null, error: null };
+  if (record && !installExpired(record)) {
+    const apiUrl = opts.apiUrl ? normalizeApiOrigin(getApiUrl(opts.apiUrl)) : record.apiUrl;
+    bindToken(record.token, apiUrl);
+    const client = new PlayerClient({ apiUrl, token: record.token, timeoutMs: 8e3 });
+    try {
+      const policy = await client.policy();
+      server.reachable = true;
+      server.policyVersion = policy.version ?? null;
+      server.minVersion = policy.minVersion ?? null;
+      server.latestVersion = policy.latestVersion ?? null;
+      let pending = 0;
+      for (const provider of new Set(runners.map((r) => PROVIDER_FOR_RUNNER[r]))) {
+        pending += (await client.pending(provider)).length;
+      }
+      server.pending = pending;
+    } catch (error) {
+      server.error = error instanceof PlayerApiError ? `${error.status} ${error.code}`.trim() : error instanceof PlayerAuthError ? "credential_rejected" : error instanceof PlayerUpdateRequiredError ? "player_update_required" : "unreachable";
+    }
+  }
+  if (opts.json) {
+    const described2 = record ? describeInstall(record) : null;
+    writeJsonLine2({
+      command: "player status",
+      status: record ? "ok" : "not_installed",
+      error: record ? null : "not_installed",
+      installed: Boolean(record),
+      apiUrl: described2?.apiUrl ?? null,
+      watcherId: described2?.watcherId ?? null,
+      label: described2?.label ?? null,
+      installedAt: described2?.installedAt ?? null,
+      version: described2?.version ?? null,
+      cliVersion: getCliVersion(),
+      credentialExpiresAt: described2?.expiresAt ?? null,
+      credentialExpired: record ? installExpired(record) : null,
+      runners,
+      autostart: unit,
+      running,
+      pid: state?.pid ?? null,
+      startedAt: state?.startedAt ?? null,
+      lastHeartbeatAt: state?.lastHeartbeatAt ?? null,
+      lastPollAt: state?.lastPollAt ?? null,
+      lastJobAt: state?.lastJobAt ?? null,
+      jobsCompleted: state?.jobsCompleted ?? null,
+      jobsReleased: state?.jobsReleased ?? null,
+      lastError: state?.lastError ?? null,
+      logFile: paths.log,
+      server
+    });
+    if (!record) process.exitCode = 1;
+    return;
+  }
+  log.plain(c.bold("genex player status"));
+  if (!record) {
+    log.plain("");
+    log.plain(`  ${PLAYER_NOT_INSTALLED}`);
+    process.exitCode = 1;
+    return;
+  }
+  const described = describeInstall(record);
+  log.dim(`  ${described.apiUrl}`);
+  log.plain("");
+  log.plain(`  Watcher      ${described.watcherId ?? "not registered yet"}${described.label ? ` \xB7 ${described.label}` : ""}`);
+  log.plain(`  Installed    ${described.installedAt} by v${described.version} (running v${getCliVersion()})`);
+  log.plain(`  Approval     ${installExpired(record) ? c.red("expired") : "valid"} until ${described.expiresAt}`);
+  log.plain(`  Runners      ${runners.length ? runners.join(", ") : "none on PATH"}`);
+  log.plain(`  Login entry  ${unit ?? "none"}`);
+  log.plain(`  Process      ${running === null ? "never started here" : running ? `running (pid ${state?.pid})` : "not running"}`);
+  if (state) {
+    log.plain(`  Last beat    ${state.lastHeartbeatAt ?? "never"}   poll ${state.lastPollAt ?? "never"}   job ${state.lastJobAt ?? "never"}`);
+    log.plain(`  Answered     ${state.jobsCompleted} \xB7 handed back ${state.jobsReleased}${state.lastError ? ` \xB7 last issue ${state.lastError}` : ""}`);
+  }
+  log.plain(`  Server       ${server.reachable ? `reachable \xB7 policy ${server.policyVersion} \xB7 needs \u2265 ${server.minVersion}, current ${server.latestVersion} \xB7 ${server.pending ?? 0} waiting` : `not reachable (${server.error ?? "unknown"})`}`);
+  log.plain(`  Log          ${paths.log}`);
+  if (installExpired(record) || server.error === "credential_rejected") process.exitCode = 1;
+}
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+async function stop(opts, log) {
+  const platform = servicePlatform();
+  const result = await stopService(os12.homedir(), platform);
+  const state = await readPlayerState();
+  let signalled = false;
+  if (state?.pid && pidAlive(state.pid) && state.pid !== process.pid && !playerDryRun()) {
+    try {
+      process.kill(state.pid, "SIGTERM");
+      signalled = true;
+    } catch {
+    }
+  }
+  if (opts.json) {
+    writeJsonLine2({ command: "player stop", status: "ok", error: null, unit: result.unit, detail: result.detail, signalledPid: signalled ? state?.pid ?? null : null });
+    return;
+  }
+  log.success(`Stopped: ${result.detail}${signalled ? ` (and signalled pid ${state?.pid})` : ""}`);
+  log.dim(`  The installation is still here \u2014 start it again with ${c.cyan("genex player run")}, or remove it with ${c.cyan("genex player uninstall")}.`);
+}
+async function uninstall(opts, log) {
+  const platform = servicePlatform();
+  const state = await readPlayerState();
+  if (state?.pid && pidAlive(state.pid) && state.pid !== process.pid && !playerDryRun()) {
+    try {
+      process.kill(state.pid, "SIGTERM");
+    } catch {
+    }
+  }
+  const service = await uninstallService(os12.homedir(), platform);
+  const removed = await removePlayerFiles();
+  if (opts.json) {
+    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)})`);
+  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 = {}) {
+  if (opts.json) writeJsonLine2({ command, status: "failed", error: message, ...extra });
+  else log.error(message);
+  process.exitCode = 1;
+}
+function writeJsonLine2(value) {
+  process.stdout.write(`${JSON.stringify(value)}
+`);
+}
+
+// src/lib/costs.ts
+var TYPICAL_CREDITS = {
+  model: 35,
+  // 46 from a reference image; --texture standard 23, --no-texture 12, --geometry detailed 58, --quad 41, --low-poly 46, --parts 58 quote off the estimate
+  image: 7,
+  // GPT Image 2.5 at high, the default; --quality xhigh/max, --candidates, --edit and 4K quote higher, --quality low/medium and --transparent quote lower
+  texture: 9,
+  // gemini-3.1-flash-image, 1K square
+  sfx: 2,
+  music: 27,
   // 90 s; up to 87 for a 300 s track
   voice: 12,
   // the 1000-char cap; short lines quote 2-3
@@ -23879,6 +26076,27 @@ ${c.bold("Usage")}
                                      the asset table against it. --assets <credits>
                                      --user-approved raises it, only once the player
                                      has agreed to the number.
+  genex llm <sub> [options]          In-game model calls: models | bench | price.
+                                     "models" says whether this stand serves the
+                                     runtime LLM lane at all, and at what provider
+                                     rates. "bench" runs the real model on YOUR OWN
+                                     coin and reports what each attempt was charged;
+                                     it needs --max-coins <n> --user-approved, like
+                                     any spend the player has to agree to. "price"
+                                     reprints the last run's recommended
+                                     estimateCoins. Declare a game's price from a
+                                     bench, never from a guess: a started attempt is
+                                     charged in full, including one that fails.
+  genex player <sub> [options]       Answer the in-game model requests you approve, on your
+                                     OWN Claude or ChatGPT subscription: install | run |
+                                     status | stop | uninstall. "install" signs this machine
+                                     in (a player-scoped approval that can spend nothing),
+                                     finds the official claude / codex CLI you already
+                                     use, and starts a small background program at login.
+                                     It never reads, stores or forwards your Claude or
+                                     ChatGPT sign-in \u2014 it only starts the CLI you installed.
+                                     Approve a request in a game and the answer comes back
+                                     on its own; nothing to paste, ever again.
   genex auth [options]               Connect this machine to your Genex account, or
                                      finish a sign-in another command started \u2014 it
                                      resumes the same code, so an interrupted
@@ -24301,6 +26519,12 @@ ${c.bold("Examples")}
   genex shop set sku_123 --icon https://assets.genex.technology/generations/abc123/image-main
   genex shop test sku_123
   genex shop remove sku_123
+  genex llm models
+  genex llm bench "Reply with one short taunt." --samples 5 --max-coins 20 --user-approved
+  genex llm price
+  genex player install
+  genex player status --json
+  genex player uninstall
   genex publish --no-push --title "My Game"
   genex model "weathered wooden barrel with iron bands"
   genex model --image ./concept.png
@@ -24530,6 +26754,76 @@ ${c.bold("How the allowance works")}
   and GENEX_ASSET_BUDGET_CAP (credits; 0 turns the budget off).
 
   Every number printed is live from your account; prices can change without a deploy.
+`,
+  llm: `${c.bold("genex llm")} \u2014 in-game model calls: is the lane live, what does one call cost, what should the game declare?
+
+${c.bold("Usage")}
+  genex llm models [--json]          Which models this stand serves, their provider rates per
+                                     million tokens, and the headroom it recommends over a
+                                     benchmark. Off on this stand: it says so and exits 0 \u2014
+                                     build the feature without a model rather than promising
+                                     a 404.
+  genex llm bench "<prompt>" --max-coins <n> --user-approved [options]
+                                     Run the real model <n> times through the development
+                                     lane and report what each attempt was CHARGED. Refused
+                                     without both flags, before any network call: this spends
+                                     YOUR OWN COIN, a wallet the build's asset allowance
+                                     cannot see. Needs a folder linked to a game you own.
+  genex llm price [--json]           The recommendation from the last bench in this folder.
+                                     Reads a file; spends nothing.
+
+${c.bold("Bench options")}
+  --model <id>         One of the ids \`genex llm models\` prints (default: the first one).
+  --samples <n>        How many real attempts (default ${DEFAULT_BENCH_SAMPLES}). More samples, better p95.
+  --schema <file>      A JSON file holding the output schema; implies JSON output.
+  --json-output        Ask for JSON without a schema.   --text  Ask for text (the default).
+  --max-coins <n>      The per-attempt ceiling YOU approved \u2014 a bench runs on your own coin,
+                       never a player's. The run's worst case is that number times --samples,
+                       and it is printed before anything starts.
+  --timeout <seconds>  Bounds the wait for each attempt.
+  --json               One machine-readable object; every key is always present, null when
+                       the CLI could not learn it.
+
+${c.bold("Why a benchmark and not an estimate")}
+  \`estimateCoins\` is a PRICE, not a guess: declaring it charges it, in full, even when the
+  attempt fails, is cancelled, or stops at its budget. And three layers sit between the
+  provider's rate card and that number \u2014 the provider's cost, the platform's tariff (already
+  inside every charged coin), and your headroom. The bench itself is billed to YOU, on the
+  development lane; the player-funded lane is what the published game uses. Adding a margin
+  to the provider's rate silently drops the tariff and under-prices every call, so the
+  recommendation is built from CHARGED COINS and the headroom comes from the server. A stand
+  that serves no headroom gets no recommendation, because the multiplier is not the CLI's to
+  invent.
+
+  Results land in ${LLM_BENCH_FILE} \u2014 gitignored, machine-local, re-read by \`genex llm price\`.
+`,
+  player: `${c.bold("genex player")} \u2014 answer the in-game model requests you approve, on your own Claude or ChatGPT subscription.
+
+${c.bold("Usage")}
+  genex player install [--label <name>] [--no-autostart] [--dry-run] [--json]
+                                     Sign this machine in, find the official CLI you already
+                                     use, and start a small background program at login.
+  genex player run [--once] [--foreground]
+                                     The loop itself: poll, take one request, run it, send the
+                                     answer back. Started for you by \`install\`; run it yourself
+                                     with --foreground to watch it work.
+  genex player status [--json]       What is installed here, what the server says, and when this
+                                     machine last spoke to it.
+  genex player stop                  Stop the background program; keep the installation.
+  genex player uninstall             Stop it, remove the login entry, delete the approval.
+
+${c.bold("What it does and does not touch")}
+  It NEVER reads, stores, forwards or intermediates your Claude or ChatGPT sign-in \u2014 no token,
+  no keychain entry, no session file. It starts the official CLI you installed and signed into,
+  hands it the request on stdin with no tools and an empty scratch directory, and reads what it
+  prints. Genex never sees your vendor account.
+
+  Its GENEX approval is a player-scoped one: it can answer requests you already approved and can
+  spend nothing \u2014 no coins, no credits, no account changes. It lives in ~/.genex/player.json,
+  separate from your creator sign-in, and the dashboard can revoke it at any time.
+
+  The log under ~/.genex/logs/ carries ids, timings and outcomes \u2014 never what a game asked for
+  and never what the model answered.
 `,
   remix: `genex remix <slug-or-Genex-page-URL> [directory] [--preview | --source-only] [--json]
 
@@ -24714,6 +27008,16 @@ function parseArgs(argv) {
     "--limit",
     // `genex budget --assets <credits>` — the allowance the player approved.
     "--assets",
+    // `genex llm bench` value flags. `--max-coins` is the COIN half of the
+    // same approval shape as `--assets` (a different economy, its own gate).
+    "--model",
+    "--samples",
+    "--schema",
+    "--max-coins",
+    // `genex player install --label <name>` — what this machine is called in
+    // the dashboard. Its own key rather than the generic 2nd positional,
+    // which `player` spends on the subcommand.
+    "--label",
     // `genex motion` value flags.
     "--takes",
     "--seeds",
@@ -24791,6 +27095,33 @@ function parseArgs(argv) {
       case "--user-approved":
         parsed.options.userApproved = true;
         break;
+      // `genex player` switches.
+      case "--no-autostart":
+        parsed.options.noAutostart = true;
+        break;
+      case "--once":
+        parsed.options.once = true;
+        break;
+      case "--foreground":
+        parsed.options.foreground = true;
+        break;
+      // Set by a watcher that re-executed ITSELF on a newer version, so the
+      // child cannot relaunch again and spin (lib/player/relaunch.ts).
+      case "--relaunched":
+        parsed.options.relaunched = true;
+        break;
+      case "--dry-run":
+        parsed.options.dryRun = true;
+        break;
+      // `genex llm bench` output shape. Named `--json-output` because `--json`
+      // already means "print one machine-readable object" everywhere in this
+      // CLI, and the model's answer format is a different question.
+      case "--json-output":
+        parsed.options.jsonOutput = true;
+        break;
+      case "--text":
+        parsed.options.textOutput = true;
+        break;
       case "--direct-text":
         parsed.options.directText = true;
         break;
@@ -24948,6 +27279,8 @@ function parseArgs(argv) {
           } else {
             (parsed.options.selectors ??= []).push(arg);
           }
+        } else if (parsed.command === "llm") {
+          parsed.options.benchPrompt = parsed.options.benchPrompt ? `${parsed.options.benchPrompt} ${arg}` : arg;
         } else if (parsed.command === "shop") {
           if (!parsed.options.hostname) parsed.options.hostname = arg;
           else {
@@ -25173,6 +27506,31 @@ function applyValueFlag(options, flag, value) {
       options.assets = n;
       break;
     }
+    case "--model":
+      options.modelId = value;
+      break;
+    case "--label":
+      options.playerLabel = value;
+      break;
+    case "--schema":
+      options.schemaPath = value;
+      break;
+    case "--samples": {
+      const n = Number(value);
+      if (!Number.isInteger(n) || n < 1 || n > 25) {
+        throw new Error(`Invalid --samples value: ${value} (expected 1-25)`);
+      }
+      options.samples = n;
+      break;
+    }
+    case "--max-coins": {
+      const n = Number(value);
+      if (!Number.isInteger(n) || n < 1) {
+        throw new Error(`Invalid --max-coins value: ${value} (whole coin, 1 or more)`);
+      }
+      options.maxCoins = n;
+      break;
+    }
     case "--timeout": {
       const n = Number(value);
       if (!Number.isFinite(n) || n <= 0) {
@@ -25384,9 +27742,11 @@ async function main() {
     return;
   }
   const isBlenderMcp = parsed.command === "blender" && parsed.options.name === "mcp";
-  const quietUpdates = Boolean(parsed.options.quiet || parsed.options.json || isBlenderMcp);
+  const isPlayerLoop = parsed.command === "player" && (parsed.options.name ?? "status") === "run";
+  const quietUpdates = Boolean(parsed.options.quiet || parsed.options.json || isBlenderMcp || isPlayerLoop);
   const updateLog = createLogger({ quiet: quietUpdates });
-  if (parsed.command !== "init" && parsed.command !== "tools" && parsed.command !== "remix") {
+  const ownsItsOwnInstall = parsed.command === "init" || parsed.command === "tools" || parsed.command === "remix";
+  if (!ownsItsOwnInstall && parsed.command !== "player") {
     await syncSkills(updateLog, workspace);
   }
   const updateCheck = startUpdateCheck();
@@ -25459,6 +27819,20 @@ async function main() {
       case "budget":
         await runBudget(parsed.options);
         break;
+      // The in-game model lane: is it live here, what does one call really
+      // cost, what should the game declare. `bench` is the only CLI command
+      // that spends COIN, so it carries its own --max-coins/--user-approved
+      // gate — the credits allowance cannot see that wallet.
+      case "llm":
+        await runLlm(parsed.options);
+        break;
+      // The PLAYER's own program, not a builder's: it answers the in-game
+      // model requests they approved by running the official `claude` /
+      // `codex` CLI they signed into themselves, and never touches a vendor
+      // credential. The second positional is the subcommand.
+      case "player":
+        await runPlayer(parsed.options);
+        break;
       case "auth":
         await runAuth(parsed.options);
         break;