@genex-ai/cli-demo 1.36.11 → 1.36.12-dev.995

package/dist/index.js

@@ -57,7 +57,7 @@ import {
   writeSecretFile,
   writeUserToken,
   writeWorkspace
-} from "./chunk-4BBTPRJW.js";
+} from "./chunk-EABIVAGT.js";
 import {
   CLI_CHANNEL,
   DEFAULT_API_URL,
@@ -78,7 +78,7 @@ import {
   normalizeApiOrigin,
   originKey,
   resolveAgentTargets
-} from "./chunk-QI7FIYBY.js";
+} from "./chunk-K4EHXOZK.js";
 
 // src/instrument.ts
 import { setTimeout as sleep } from "timers/promises";
@@ -1107,7 +1107,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). One file in \`.genex/scratch/\` IS read, by the platform: \`.genex/scratch/cover.png\` is the game's cover \u2014 the frame you would put on its poster: real gameplay at its signature moment, well lit, no menus, popups or busy HUD, landscape 16:9, and never any text (the page sets the title beside it). The next \`genex preview\` makes it the cover; save a better moment over it whenever one comes along, and if your browser tool can set the cover itself, use that instead. Before the first publish, and whenever the game's look changes, load \`$genex-cover\`: it chooses, stages, lights and judges that frame.
-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.
+24. **Benchmark before declaring an in-game LLM ceiling.** If the game calls a language model while the player plays \u2014 an NPC answering in its own words, a quest written for this save, a judge reading what the player typed \u2014 the PLAYER pays for it from their Genex credits, billed as used, and the game declares no price, only a per-call CEILING: \`maxCredits\` on \`generate()\`, \`perCallMaxCredits\` on a standing budget. That ceiling bounds what one call may cost AND funds how long its answer may be, so never pick it by judgement or from a vendor's rate card. Run the real prompt on your own credits \u2014 \`npx genex llm bench "<the prompt>" --schema <file> --samples 3 --max-credits <n> --user-approved\` \u2014 and declare the figures it prints, recorded in \`DESIGN.md\` with its model and date; re-benchmark whenever the prompt, the schema or the model changes, because a prompt edit changes the ceiling. Check the lane first with \`npx genex llm models\`: where it is off the routes 404, so build the feature behind a graceful unavailable state and say so in the handoff. A repeated call is a standing budget the player approves once (\`requestSpendGrant()\`, then \`generate({ grantId })\`), never a popup per turn, and its disclosed call rate and credits per period are computed from the game's own loop and the bench's measured average. The coin spellings (\`estimateCoins\`, \`perCallMaxCoins\`) are deprecated \u2014 write the credit names. Model output is data the game validates against its own expectation \u2014 never executed, and never authority over coin, credits, items, entitlements or rewards. Load \`$genex-llm-in-games\` before writing any of it.
 ${CONTRACT_END}
 `;
 var TOOLS_CONTRACT_HEAD = `# Genex Tools (always in effect in this folder)
@@ -1121,7 +1121,7 @@ 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?`;
+var TOOLS_CONTRACT_LLM_OFFER = `A model running while people play is built into the Genex platform \u2014 the player pays, with their Genex credits 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.`;
@@ -2671,8 +2671,11 @@ function tierFor(estVramMb) {
 }
 
 // src/lib/download-assets.ts
+import { createWriteStream } from "fs";
 import fs12 from "fs/promises";
 import path13 from "path";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
 var RUNG_ROLE = /@\d+$/;
 function isPrimaryRole(role) {
   return !RUNG_ROLE.test(role);
@@ -2704,21 +2707,37 @@ async function downloadAssets(files, opts) {
     return result;
   }
   const multi = wanted.length > 1;
-  for (const file of wanted) {
-    const dest = path13.join(opts.outDir, localAssetName(opts.kind, opts.prompt, opts.id, file, multi));
+  const outcomes = await Promise.all(
+    wanted.map(
+      (file) => saveOne(file, path13.join(opts.outDir, localAssetName(opts.kind, opts.prompt, opts.id, file, multi)))
+    )
+  );
+  for (const outcome2 of outcomes) {
+    if ("failure" in outcome2) result.failures.push(outcome2.failure);
+    else result.saved.push(outcome2);
+  }
+  return result;
+}
+async function saveOne(file, dest) {
+  try {
+    const res = await fetch(file.url);
+    if (!res.ok || !res.body) throw new Error(`HTTP ${res.status}`);
+    let bytes = 0;
+    const counted = Readable.fromWeb(res.body).on("data", (chunk) => {
+      bytes += chunk.byteLength;
+    });
     try {
-      const res = await fetch(file.url);
-      if (!res.ok) throw new Error(`HTTP ${res.status}`);
-      const buf = Buffer.from(await res.arrayBuffer());
-      await fs12.writeFile(dest, buf);
-      result.saved.push({ role: file.role, path: dest, url: file.url, bytes: buf.byteLength });
+      await pipeline(counted, createWriteStream(dest));
     } catch (err) {
-      result.failures.push(
-        `${file.role}: ${err instanceof Error ? err.message : String(err)} \u2014 the asset is still live at ${file.url}`
-      );
+      await fs12.rm(dest, { force: true });
+      throw err;
     }
+    return { role: file.role, path: dest, url: file.url, bytes };
+  } catch (err) {
+    return {
+      failure: `${file.role}: ${err instanceof Error ? err.message : String(err)} \u2014 the asset is still live at ${file.url}`
+    };
   }
-  return result;
 }
 function formatBytes(bytes) {
   if (bytes >= 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
@@ -6245,6 +6264,16 @@ async function pushSource(cwd, ctx, log, branch = "main", expectStagingCommit, o
   ) === true;
 }
 var WORKSPACE_SOURCE_REF = "workspace";
+function gitLfsInstallCommand(platform) {
+  if (platform === "darwin") {
+    return {
+      bin: "brew",
+      args: ["install", "git-lfs"],
+      env: { HOMEBREW_NO_AUTO_UPDATE: "1", HOMEBREW_NO_INSTALL_CLEANUP: "1" }
+    };
+  }
+  return { bin: "sudo", args: ["-n", "apt-get", "install", "-y", "git-lfs"], env: {} };
+}
 async function pushWorktree(cwd, pushUrl, managed, log, branch = "main", onCommit, skipSizeCheck = false, limits) {
   const EMPTY_TREE = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
   const failed = () => {
@@ -6271,8 +6300,8 @@ async function pushWorktree(cwd, pushUrl, managed, log, branch = "main", onCommi
     let lfs = (await run("git", ["lfs", "version"], base)).code !== 0 ? false : true;
     if (!lfs) {
       log.step("Installing git-lfs (keeps large binary assets out of the source push)\u2026");
-      const [bin, args] = process.platform === "darwin" ? ["brew", ["install", "git-lfs"]] : ["sudo", ["-n", "apt-get", "install", "-y", "git-lfs"]];
-      await run(bin, args, base);
+      const install2 = gitLfsInstallCommand(process.platform);
+      await run(install2.bin, install2.args, { ...base, ...install2.env });
       lfs = (await run("git", ["lfs", "version"], base)).code === 0;
       if (!lfs) {
         log.warn(
@@ -23778,7 +23807,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(
@@ -23787,7 +23816,7 @@ async function runBlender(opts) {
     return serveLocalBlender({ port, log });
   }
   if (sub === "mcp") {
-    const { runBlenderMcp } = await import("./blender-mcp-QVEGHE5L.js");
+    const { runBlenderMcp } = await import("./blender-mcp-WSURPZET.js");
     return runBlenderMcp();
   }
   if (sub === "seat") {
@@ -24295,7 +24324,12 @@ import fs35 from "fs/promises";
 import path36 from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 var SUBS3 = ["models", "bench", "price", "status", "cancel"];
-var LLM_BENCH_APPROVAL_REQUIRED = "STOP: `genex llm bench` runs the real model and spends YOUR OWN 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_BENCH_APPROVAL_REQUIRED = "STOP: `genex llm bench` runs the real model and spends YOUR OWN credits \u2014 your balance, not a player's, and a spend this build's asset allowance does not count. Re-run with --max-credits <n> --user-approved only after the person at the keyboard agreed to the number.";
+var LLM_MAX_COINS_DEPRECATED = "--max-coins is deprecated: it is read as --max-credits, the same number \u2014 a bench spends credits now.";
+function benchBalanceShortLine(spendable, maxCredits) {
+  return `Your spendable credits (${spendable}) cannot cover one attempt at --max-credits ${maxCredits} \u2014 nothing was sent, nothing was spent. Add credits, or re-run with a lower --max-credits once the person at the keyboard agrees to it.`;
+}
+var LLM_BENCH_UNVERIFIED_LINE = "Credits pay only for a verified email, and this account's is not verified yet (credits_unverified) \u2014 nothing was sent, nothing was spent. Verify it, then re-run.";
 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",
@@ -24308,7 +24342,7 @@ function serverSlotCounts(body) {
   return { held: body.slotsHeld, limit: body.slotLimit };
 }
 var PENDING_SLOT_RELEASE_MINUTES = 10;
-var LLM_STATUS_LEGEND = `"awaiting bill" = the call has stopped but the provider's bill is not final, so its coin stays held until the bill resolves; such a row stops holding a slot ${PENDING_SLOT_RELEASE_MINUTES} minutes after dispatch.`;
+var LLM_STATUS_LEGEND = `"awaiting bill" = the call has stopped but the provider's bill is not final, so what it reserved stays held until the bill resolves; such a row stops holding a slot ${PENDING_SLOT_RELEASE_MINUTES} minutes after dispatch.`;
 var LLM_STATUS_NO_COUNT_LINE = "This stand does not report how many slots are held across your projects, so no count is shown.";
 var LLM_CANCEL_AWAITING_BILL = "this call already stopped; its bill is awaiting the provider";
 var LLM_CANCEL_ALREADY_FINAL = "this call is already final";
@@ -24322,11 +24356,33 @@ var DEFAULT_SAMPLE_TIMEOUT_SEC = 180;
 function parseProviderKey(value) {
   return value === "ok" || value === "rejected" || value === "unknown" ? value : null;
 }
+function bpsOrNull(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
+}
+function standingCreditGrantOrNull(value) {
+  if (!value || typeof value !== "object") return null;
+  const v = value;
+  const whole = (x) => typeof x === "number" && Number.isSafeInteger(x) && x >= 0;
+  if (!whole(v.minCredits) || !whole(v.maxCredits) || !whole(v.stepCredits) || !whole(v.defaultCredits)) return null;
+  return {
+    minCredits: v.minCredits,
+    maxCredits: v.maxCredits,
+    stepCredits: v.stepCredits,
+    defaultCredits: v.defaultCredits,
+    ...whole(v.minUsdCents) ? { minUsdCents: v.minUsdCents } : {},
+    ...whole(v.maxUsdCents) ? { maxUsdCents: v.maxUsdCents } : {},
+    ...whole(v.stepUsdCents) ? { stepUsdCents: v.stepUsdCents } : {}
+  };
+}
 async function readRuntimeLane(apiUrl, token) {
   const empty = (state) => ({
     state,
     models: null,
     recommendedDeclaredHeadroomBps: null,
+    currency: null,
+    feeBps: null,
+    usdCentsPerCredit: null,
+    standingCreditGrant: null,
     externalProviders: null,
     total: null,
     featuredCount: null,
@@ -24345,7 +24401,11 @@ async function readRuntimeLane(apiUrl, token) {
     return {
       state: "live",
       models: body.models,
-      recommendedDeclaredHeadroomBps: typeof body.recommendedDeclaredHeadroomBps === "number" && Number.isFinite(body.recommendedDeclaredHeadroomBps) ? body.recommendedDeclaredHeadroomBps : null,
+      recommendedDeclaredHeadroomBps: bpsOrNull(body.recommendedDeclaredHeadroomBps),
+      currency: body.currency === "credits" || body.currency === "coins" ? body.currency : null,
+      feeBps: bpsOrNull(body.feeBps),
+      usdCentsPerCredit: typeof body.usdCentsPerCredit === "number" && Number.isSafeInteger(body.usdCentsPerCredit) && body.usdCentsPerCredit >= 1 ? body.usdCentsPerCredit : null,
+      standingCreditGrant: standingCreditGrantOrNull(body.standingCreditGrant),
       externalProviders: Array.isArray(body.externalProviders) ? body.externalProviders : null,
       total: typeof body.total === "number" && Number.isFinite(body.total) ? body.total : null,
       featuredCount: typeof body.featuredCount === "number" && Number.isFinite(body.featuredCount) ? body.featuredCount : null,
@@ -24361,18 +24421,45 @@ function percentile2(values, p) {
   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 percentilePicos(values, p) {
+  if (values.length === 0) return null;
+  const sorted = [...values].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  const rank2 = Math.ceil(p / 100 * sorted.length);
+  return sorted[Math.min(sorted.length - 1, Math.max(0, rank2 - 1))];
 }
-function recommendPerCallMaxCoins(p95, max, headroomBps) {
-  return Math.max(recommendEstimateCoins(p95, headroomBps), recommendEstimateCoins(max, headroomBps));
+var PICOS_PER_CENT = 10000000000n;
+function ceilingCreditsFor(costPicos, terms) {
+  if (costPicos <= 0n) return 1;
+  const num = costPicos * BigInt(1e4 + terms.feeBps) * BigInt(1e4 + terms.headroomBps);
+  const den = 100000000n * BigInt(terms.usdCentsPerCredit) * PICOS_PER_CENT;
+  return Math.max(1, Number((num + den - 1n) / den));
+}
+function averageCreditsPerCall(costsPicos, terms) {
+  if (costsPicos.length === 0) return null;
+  const sum = costsPicos.reduce((a, b) => a + b, 0n);
+  return Number(sum * BigInt(1e4 + terms.feeBps)) / Number(BigInt(costsPicos.length) * 10000n * BigInt(terms.usdCentsPerCredit) * PICOS_PER_CENT);
+}
+function perCallEstimateCreditsFor(costsPicos, terms) {
+  if (costsPicos.length === 0) return null;
+  const sum = costsPicos.reduce((a, b) => a + b, 0n);
+  const num = sum * BigInt(1e4 + terms.feeBps);
+  const den = BigInt(costsPicos.length) * 10000n * BigInt(terms.usdCentsPerCredit) * PICOS_PER_CENT;
+  return Math.max(1, Number((num + den - 1n) / den));
+}
+function formatCredits(value) {
+  if (!Number.isFinite(value)) return "\u2014";
+  if (value >= 100) return String(Math.round(value));
+  return String(Number(value.toPrecision(value < 1 ? 2 : 3)));
+}
+function usdFromPicos(picos) {
+  if (picos === null || picos === void 0) return "unknown";
+  const value = typeof picos === "bigint" ? picos : /^\d+$/.test(picos) ? BigInt(picos) : null;
+  if (value === null) return "unknown";
+  return `$${(Number(value) / 1e12).toFixed(6)}`;
 }
 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();
@@ -24398,16 +24485,23 @@ async function runLlm(opts = {}) {
     return;
   }
   if (sub === "bench") {
-    if (opts.maxCoins === void 0 || opts.userApproved !== true) {
+    if (opts.maxCoins !== void 0) process.stderr.write(`${c.yellow("!")} ${LLM_MAX_COINS_DEPRECATED}
+`);
+    if (opts.maxCoins !== void 0 && opts.maxCredits !== void 0 && opts.maxCoins !== opts.maxCredits) {
+      fail5("llm bench", `Pass --max-credits alone \u2014 --max-coins is its deprecated name, and the two disagree (${opts.maxCredits} vs ${opts.maxCoins}).`);
+      return;
+    }
+    const approvedCredits = opts.maxCredits ?? opts.maxCoins;
+    if (approvedCredits === void 0 || opts.userApproved !== true) {
       fail5("llm bench", LLM_BENCH_APPROVAL_REQUIRED);
       return;
     }
-    if (!Number.isInteger(opts.maxCoins) || opts.maxCoins < 1) {
-      fail5("llm bench", `--max-coins takes a whole number of coin, 1 or more (got ${String(opts.maxCoins)}).`);
+    if (!Number.isInteger(approvedCredits) || approvedCredits < 1) {
+      fail5("llm bench", `--max-credits takes a whole number of credits, 1 or more (got ${String(approvedCredits)}).`);
       return;
     }
     if (!opts.benchPrompt?.trim()) {
-      fail5("llm bench", '`genex llm bench` needs the prompt your game would send, e.g. genex llm bench "<prompt>" --max-coins <n> --user-approved.');
+      fail5("llm bench", '`genex llm bench` needs the prompt your game would send, e.g. genex llm bench "<prompt>" --max-credits <n> --user-approved.');
       return;
     }
     if (opts.jsonOutput && opts.textOutput) {
@@ -24499,6 +24593,10 @@ async function reportModels(apiUrl, token, opts, log, toolsOnly = false) {
         models: null,
         externalProviders: null,
         recommendedDeclaredHeadroomBps: null,
+        currency: null,
+        feeBps: null,
+        usdCentsPerCredit: null,
+        standingCreditGrant: null,
         total: null,
         featuredCount: null,
         // The stand was never asked, so the verdict is unknown — but the key is
@@ -24524,6 +24622,12 @@ async function reportModels(apiUrl, token, opts, log, toolsOnly = false) {
       models: lane.models,
       externalProviders: lane.externalProviders,
       recommendedDeclaredHeadroomBps: lane.recommendedDeclaredHeadroomBps,
+      // The credit terms a call is billed on, the server's — null on a stand
+      // that predates credit billing, never a number the CLI filled in.
+      currency: lane.currency,
+      feeBps: lane.feeBps,
+      usdCentsPerCredit: lane.usdCentsPerCredit,
+      standingCreditGrant: lane.standingCreditGrant,
       total: lane.total ?? lane.models?.length ?? null,
       featuredCount: lane.featuredCount ?? (lane.models ? lane.models.filter((m) => m.featured).length : null),
       // `null` when the lane is not live or the server predates the probe.
@@ -24570,8 +24674,9 @@ async function reportModels(apiUrl, token, opts, log, toolsOnly = false) {
   );
   for (const m of shown) {
     const plan = m.personalPlan ? `  \xB7  personal plan: ${m.personalPlan}` : "";
+    const kind = m.kind === "typesafe" ? "  \xB7  judge (classifier): judge() under a budget, not generate() or bench" : "";
     log.plain(
-      `    ${c.cyan(m.id)}  ${m.label} \u2014 ${usdPerMillion(m.inputUsdPerMillion)} in / ${usdPerMillion(m.outputUsdPerMillion)} out per million tokens${plan}`
+      `    ${c.cyan(m.id)}  ${m.label} \u2014 ${usdPerMillion(m.inputUsdPerMillion)} in / ${usdPerMillion(m.outputUsdPerMillion)} out per million tokens${plan}${kind}`
     );
   }
   if (hiddenCount > 0) {
@@ -24587,74 +24692,104 @@ async function reportModels(apiUrl, token, opts, log, toolsOnly = false) {
   }
   log.plain("");
   if (lane.recommendedDeclaredHeadroomBps === null) {
-    log.dim("  This stand serves no recommended headroom, so no price can be recommended from a bench.");
+    log.dim("  This stand serves no recommended headroom, so no ceiling can be recommended from a bench.");
   } else {
-    log.dim(`  Recommended headroom over benchmarked coins on this stand: ${lane.recommendedDeclaredHeadroomBps} bps.`);
+    log.dim(`  Recommended headroom over a benchmarked call's cost on this stand: ${lane.recommendedDeclaredHeadroomBps} bps.`);
+  }
+  if (lane.feeBps === null) {
+    log.dim("  This stand serves no platform fee \u2014 it predates credit billing, so no ceiling can be recommended from a bench.");
+  } else {
+    log.dim(`  In-game calls are billed in the player's credits, as used: the provider's cost plus this stand's platform fee (${lane.feeBps} 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')}`);
+  log.dim("  Those per-million rates are the PROVIDER's list; what one call of YOUR prompt really costs,");
+  log.dim(`  and the per-call ceiling to declare, only a real call measures: ${c.cyan('genex llm bench "<prompt>" --max-credits <n> --user-approved')}`);
 }
 function wholeOrNull(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
 }
+function costPicosOf(usage) {
+  if (typeof usage?.costUsdPicos === "string" && /^\d+$/.test(usage.costUsdPicos)) return usage.costUsdPicos;
+  if (typeof usage?.costUsd === "number" && Number.isFinite(usage.costUsd) && usage.costUsd >= 0) {
+    return String(BigInt(Math.round(usage.costUsd * 1e12)));
+  }
+  return null;
+}
 function sampleFrom(id, settled) {
   const usage = settled?.usage;
+  const picos = costPicosOf(usage);
   return {
     id,
     status: settled?.status ?? null,
     billingStatus: settled?.billingStatus ?? null,
-    chargedCoins: typeof settled?.chargedCoins === "number" ? settled.chargedCoins : null,
-    costUsd: typeof usage?.costUsd === "number" ? usage.costUsd : null,
+    chargedCredits: wholeOrNull(settled?.chargedCredits),
+    costUsd: typeof usage?.costUsd === "number" ? usage.costUsd : picos !== null ? Number(picos) / 1e12 : null,
+    costUsdPicos: picos,
     error: settled?.error ?? (settled ? null : "timed_out"),
     providerMessage: typeof settled?.providerMessage === "string" && settled.providerMessage.trim() ? settled.providerMessage.trim() : null,
     inputTokens: wholeOrNull(usage?.inputTokens),
     outputTokens: wholeOrNull(usage?.outputTokens),
     maxOutputTokens: wholeOrNull(usage?.maxOutputTokens),
-    fitCoins: typeof usage?.fitCoins === "number" && Number.isSafeInteger(usage.fitCoins) && usage.fitCoins >= 1 ? usage.fitCoins : null,
+    fitCredits: typeof usage?.fitCredits === "number" && Number.isSafeInteger(usage.fitCredits) && usage.fitCredits >= 1 ? usage.fitCredits : null,
     fitExceedsCap: typeof usage?.fitExceedsCap === "boolean" ? usage.fitExceedsCap : null,
     truncated: typeof usage?.truncated === "boolean" ? usage.truncated : settled?.error === "provider_token_limit" ? true : null
   };
 }
 var PROVIDER_TOKEN_LIMIT = "provider_token_limit";
-function benchRecommendation(results, headroomBps) {
-  const settled = results.filter((r) => r.status === "succeeded" && r.billingStatus === "final" && typeof r.chargedCoins === "number");
-  const charged = settled.map((r) => r.chargedCoins);
-  const fits = settled.map((r) => r.fitCoins).filter((v) => typeof v === "number");
-  const p95 = percentile2(charged, 95);
-  const max = charged.length ? Math.max(...charged) : null;
+function benchRecommendation(results, terms) {
+  const settled = results.filter(
+    (r) => r.status === "succeeded" && r.billingStatus === "final" && r.chargedCredits !== null && r.costUsdPicos !== null
+  );
+  const costs = settled.map((r) => BigInt(r.costUsdPicos));
+  const charged = settled.map((r) => r.chargedCredits);
+  const fits = settled.map((r) => r.fitCredits).filter((v) => typeof v === "number");
+  const costP95 = percentilePicos(costs, 95);
+  const costMax = costs.length ? costs.reduce((a, b) => b > a ? b : a) : null;
   const fitP95 = percentile2(fits, 95);
   const fitMax = fits.length ? Math.max(...fits) : null;
   const exceedsStandCap = results.some((r) => r.fitExceedsCap === true);
   const cutOffSamples = results.filter((r) => r.error === PROVIDER_TOKEN_LIMIT && r.fitExceedsCap !== true).length;
   const noRecommendationReason = exceedsStandCap ? "answer_exceeds_stand_cap" : cutOffSamples > 0 ? "answer_cut_off" : null;
-  const chargedBased = p95 !== null && headroomBps !== null ? recommendEstimateCoins(p95, headroomBps) : null;
-  const recommended = chargedBased === null || noRecommendationReason !== null ? null : Math.max(chargedBased, fitP95 ?? 0);
-  const ceiling = recommended === null || p95 === null || max === null || headroomBps === null ? null : Math.max(recommendPerCallMaxCoins(p95, max, headroomBps), recommended, fitMax ?? 0);
+  const { headroomBps, feeBps, usdCentsPerCredit } = terms;
+  const missingTerms = headroomBps === null ? "headroom" : feeBps === null || usdCentsPerCredit === null ? "credit_terms" : null;
+  const full = headroomBps !== null && feeBps !== null && usdCentsPerCredit !== null ? { headroomBps, feeBps, usdCentsPerCredit } : null;
+  const billing = feeBps !== null && usdCentsPerCredit !== null ? { feeBps, usdCentsPerCredit } : null;
+  const costBased = full !== null && costP95 !== null ? ceilingCreditsFor(costP95, full) : null;
+  const recommended = costBased === null || noRecommendationReason !== null ? null : Math.max(costBased, fitP95 ?? 0);
+  const ceiling = recommended === null || costMax === null || full === null ? null : Math.max(ceilingCreditsFor(costMax, full), recommended, fitMax ?? 0);
+  const average = billing !== null ? averageCreditsPerCall(costs, billing) : null;
+  const estimate = ceiling === null || billing === null ? null : Math.min(ceiling, perCallEstimateCreditsFor(costs, billing) ?? 1);
   return {
+    costs,
     charged,
-    p50: percentile2(charged, 50),
-    p95,
-    max,
+    costP50: percentilePicos(costs, 50),
+    costP95,
+    costMax,
+    chargedP50: percentile2(charged, 50),
+    chargedP95: percentile2(charged, 95),
+    chargedMax: charged.length ? Math.max(...charged) : null,
     fits,
     fitP95,
     fitMax,
-    chargedBasedEstimateCoins: chargedBased,
-    recommendedEstimateCoins: recommended,
-    recommendedPerCallMaxCoins: ceiling,
-    lengthRaisedPrice: recommended !== null && chargedBased !== null && recommended > chargedBased,
+    costBasedMaxCredits: costBased,
+    recommendedMaxCredits: recommended,
+    recommendedPerCallMaxCredits: ceiling,
+    averageCreditsPerCall: average,
+    recommendedPerCallEstimateCredits: estimate,
+    lengthRaisedCeiling: recommended !== null && costBased !== null && recommended > costBased,
     cutOffSamples,
     exceedsStandCap,
-    noRecommendationReason
+    noRecommendationReason,
+    missingTerms
   };
 }
-var LLM_LENGTH_RAISED_LINE = "The declared price also pays for how long the answer may be: at the charged-based price the answer would be cut off, so declare this one.";
-var LLM_EXCEEDS_STAND_CAP_LINE = "No price recommended: this answer is longer than one call on this stand may produce. Ask for a shorter answer \u2014 fewer fields, shorter strings, a length the prompt states \u2014 and benchmark again.";
-function benchCutOffLine(cutOff, maxCoins) {
-  return `No price recommended: ${cutOff} sample${cutOff === 1 ? " was" : "s were"} cut off at this ceiling (--max-coins ${maxCoins}) before the answer was finished, so its real length is unknown. Re-run with a higher --max-coins.`;
+var LLM_LENGTH_RAISED_LINE = "The ceiling also decides how long the answer may be: at the cost-based ceiling the answer would be cut off, so declare this one.";
+var LLM_EXCEEDS_STAND_CAP_LINE = "No ceiling recommended: this answer is longer than one call on this stand may produce. Ask for a shorter answer \u2014 fewer fields, shorter strings, a length the prompt states \u2014 and benchmark again.";
+function benchCutOffLine(cutOff, maxCredits) {
+  return `No ceiling recommended: ${cutOff} sample${cutOff === 1 ? " was" : "s were"} cut off at this ceiling (--max-credits ${maxCredits}) before the answer was finished, so its real length is unknown. Re-run with a higher --max-credits.`;
 }
 var ACTIVE_STATUSES = /* @__PURE__ */ new Set(["requires_confirmation", "queued", "dispatching", "awaiting_external"]);
 function rowState(row) {
@@ -24665,7 +24800,22 @@ function rowState(row) {
 function rowHoldsSlot(row) {
   if (typeof row.slotHeld === "boolean") return row.slotHeld;
   const state = rowState(row);
-  return state === "active" || state === "awaiting bill" && (row.reservedCoins ?? 0) > 0;
+  return state === "active" || state === "awaiting bill" && ((row.reservedCoins ?? 0) > 0 || (row.reservedCredits ?? 0) > 0);
+}
+function rowMoney(row) {
+  const credits = row.currency === "credits" || row.currency === void 0 && typeof row.reservedCredits === "number" && typeof row.reservedCoins !== "number";
+  if (credits) {
+    return {
+      unit: "credits",
+      reserved: typeof row.reservedCredits === "number" ? row.reservedCredits : null,
+      charged: typeof row.chargedCredits === "number" ? row.chargedCredits : null
+    };
+  }
+  return {
+    unit: "coin",
+    reserved: typeof row.reservedCoins === "number" ? row.reservedCoins : null,
+    charged: typeof row.chargedCoins === "number" ? row.chargedCoins : null
+  };
 }
 function providerRefusalStatus(error) {
   const m = /^provider_http_(\d{3})$/.exec(error ?? "");
@@ -24684,7 +24834,7 @@ function formatAge(iso, now = Date.now()) {
 }
 async function runBench(args) {
   const { apiUrl, token, projectId, cwd, opts, log } = args;
-  const maxCoins = opts.maxCoins;
+  const maxCredits = opts.maxCredits ?? opts.maxCoins;
   const samples = opts.samples ?? DEFAULT_BENCH_SAMPLES;
   const prompt = opts.benchPrompt.trim();
   const auth = { Authorization: `Bearer ${token}`, "Content-Type": "application/json" };
@@ -24706,7 +24856,7 @@ async function runBench(args) {
   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 });
+      if (opts.json) writeJsonLine({ ...emptyBenchJson(apiUrl, projectId, prompt, outputFormat, samples, maxCredits, opts), status: "off", error: null });
       else {
         log.plain(LLM_LANE_OFF_LINE);
         log.dim("  Nothing was spent.");
@@ -24733,17 +24883,27 @@ async function runBench(args) {
     );
     return;
   }
-  const balanceBefore = await readCoinBalance(apiUrl, token);
+  const walletBefore = await fetchCreditsSnapshot(apiUrl, token);
+  if (walletBefore?.emailVerified === false) {
+    benchFailed(opts, log, LLM_BENCH_UNVERIFIED_LINE);
+    return;
+  }
+  if (walletBefore !== null && walletBefore.spendable < maxCredits) {
+    benchFailed(opts, log, benchBalanceShortLine(walletBefore.spendable, maxCredits));
+    return;
+  }
+  const balanceBefore = walletBefore?.spendable ?? null;
   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(`  Approved     ${maxCredits} credit${maxCredits === 1 ? "" : "s"} per attempt \u2014 at worst ${maxCredits * samples} credits for this run, from your own balance`);
     log.plain(
-      `  Balance      ${balanceBefore === null ? "couldn't be read" : `${balanceBefore} coin spendable`}`
+      `  Balance      ${balanceBefore === null ? "couldn't be read" : `${balanceBefore} credits spendable`}`
     );
+    log.dim("  Billed as used: each attempt is charged its real cost plus the platform fee, rounded up to a whole credit.");
     log.plain("");
   }
   const base = `${apiUrl}/api/runtime/development/projects/${encodeURIComponent(projectId)}/generations`;
@@ -24769,7 +24929,7 @@ async function runBench(args) {
       const res = await call2(base, {
         method: "POST",
         body: JSON.stringify({
-          maxCoins,
+          maxCredits,
           request: {
             idempotencyKey: `bench-${randomUUID2()}`,
             modelId,
@@ -24799,13 +24959,14 @@ async function runBench(args) {
       if (refusedAt !== null) providerRefused++;
       if (!opts.json) {
         const length = row.outputTokens !== null ? ` \xB7 ${row.outputTokens}${row.maxOutputTokens !== null ? ` of ${row.maxOutputTokens}` : ""} tokens out` : "";
+        const charged = row.chargedCredits === null ? "\u2014" : String(row.chargedCredits);
         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)}${length}${row.error ? ` \xB7 ${row.error}` : ""}`
+          `  ${row.status === "succeeded" ? c.green("\u2713") : c.yellow("!")} sample ${i + 1}  ${charged.padStart(4)} credit${row.chargedCredits === 1 ? "" : "s"} charged \xB7 cost ${usdFromPicos(row.costUsdPicos)}${length}${row.error ? ` \xB7 ${row.error}` : ""}`
         );
         if (refusedAt !== null) printProviderRefusal(log, refusedAt, row.providerMessage, row.status === "unknown");
         if (row.error === PROVIDER_TOKEN_LIMIT) {
           log.dim(
-            row.fitExceedsCap === true ? "      The answer was cut off at this stand's own output limit \u2014 no price makes room for it; it is not a sample." : `      The answer was cut off at this ceiling (--max-coins ${maxCoins}) before it was finished \u2014 it was charged, and it is not a sample.`
+            row.fitExceedsCap === true ? "      The answer was cut off at this stand's own output limit \u2014 no ceiling makes room for it; it is not a sample." : `      The answer was cut off at this ceiling (--max-credits ${maxCredits}) before it was finished \u2014 it was charged, and it is not a sample.`
           );
         }
       }
@@ -24813,16 +24974,19 @@ async function runBench(args) {
   } finally {
     process.removeListener("SIGINT", onSigint);
   }
-  const headroomBps = lane.recommendedDeclaredHeadroomBps;
-  const rec = benchRecommendation(results, headroomBps);
-  const { charged, p50, p95, max } = rec;
-  const settledCount = charged.length;
-  const recommended = rec.recommendedEstimateCoins;
-  const ceiling = rec.recommendedPerCallMaxCoins;
+  const terms = {
+    headroomBps: lane.recommendedDeclaredHeadroomBps,
+    feeBps: lane.feeBps,
+    usdCentsPerCredit: lane.usdCentsPerCredit
+  };
+  const rec = benchRecommendation(results, terms);
+  const settledCount = rec.charged.length;
   const lengthBlocked = rec.noRecommendationReason !== null;
-  const balanceAfter = await readCoinBalance(apiUrl, token);
+  const balanceAfter = (await fetchCreditsSnapshot(apiUrl, token))?.spendable ?? null;
+  const picosOrNull = (v) => v === null ? null : String(v);
   const record = {
-    v: 1,
+    v: 2,
+    currency: "credits",
     ranAt: (/* @__PURE__ */ new Date()).toISOString(),
     apiUrl,
     projectId,
@@ -24831,28 +24995,34 @@ async function runBench(args) {
     outputFormat,
     samples,
     completed: settledCount,
-    chargedCoins: charged,
-    p50,
-    p95,
-    max,
-    recommendedDeclaredHeadroomBps: headroomBps,
-    recommendedEstimateCoins: recommended,
-    recommendedPerCallMaxCoins: ceiling,
-    maxCoinsPerSample: maxCoins,
-    fitCoins: rec.fits,
+    maxCreditsPerSample: maxCredits,
+    costUsdPicos: rec.costs.map(String),
+    chargedCredits: rec.charged,
+    cost: { p50: picosOrNull(rec.costP50), p95: picosOrNull(rec.costP95), max: picosOrNull(rec.costMax) },
+    charged: { p50: rec.chargedP50, p95: rec.chargedP95, max: rec.chargedMax },
+    fitCredits: rec.fits,
     fitP95: rec.fitP95,
-    chargedBasedEstimateCoins: rec.chargedBasedEstimateCoins,
-    lengthRaisedPrice: rec.lengthRaisedPrice,
+    fitMax: rec.fitMax,
+    recommendedDeclaredHeadroomBps: terms.headroomBps,
+    feeBps: terms.feeBps,
+    usdCentsPerCredit: terms.usdCentsPerCredit,
+    costBasedMaxCredits: rec.costBasedMaxCredits,
+    recommendedMaxCredits: rec.recommendedMaxCredits,
+    recommendedPerCallMaxCredits: rec.recommendedPerCallMaxCredits,
+    averageCreditsPerCall: rec.averageCreditsPerCall,
+    recommendedPerCallEstimateCredits: rec.recommendedPerCallEstimateCredits,
+    lengthRaisedCeiling: rec.lengthRaisedCeiling,
     cutOffSamples: rec.cutOffSamples,
     noRecommendationReason: rec.noRecommendationReason
   };
   const savedTo = await saveBench(cwd, record);
   if (opts.json) {
-    const ok = charged.length > 0 && !lengthBlocked;
+    const ok = settledCount > 0 && !lengthBlocked;
     writeJsonLine({
       command: "llm bench",
       status: ok ? "ok" : "failed",
       error: ok ? null : rec.noRecommendationReason ?? "no_sample_settled",
+      currency: "credits",
       apiUrl,
       projectId,
       modelId,
@@ -24861,35 +25031,54 @@ async function runBench(args) {
       schemaPath: opts.schemaPath ?? null,
       samples,
       completed: settledCount,
-      maxCoinsPerSample: maxCoins,
+      maxCreditsPerSample: maxCredits,
+      // Spendable credits before and after the run; null when unreadable.
       balanceBefore,
       balanceAfter,
       results,
       // The create-time refusal that ended the run, or null. Beside the
       // samples, never among them: no attempt existed and nothing was spent.
       refusal: refusal2,
-      chargedCoins: { p50, p95, max },
-      // The answer's LENGTH, priced by the server per sample (`fitCoins`,
+      // Over the settled samples: the real provider cost (pico-dollar strings
+      // and USD) and the whole credits charged.
+      costUsdPicos: record.cost,
+      costUsd: {
+        p50: rec.costP50 === null ? null : Number(rec.costP50) / 1e12,
+        p95: rec.costP95 === null ? null : Number(rec.costP95) / 1e12,
+        max: rec.costMax === null ? null : Number(rec.costMax) / 1e12
+      },
+      chargedCredits: record.charged,
+      // The answer's LENGTH, priced by the server per sample (`fitCredits`,
       // headroom already on the tokens), over the settled samples.
-      fitCoins: { p95: rec.fitP95, max: rec.fitMax },
-      chargedBasedEstimateCoins: rec.chargedBasedEstimateCoins,
-      lengthRaisedPrice: rec.lengthRaisedPrice,
+      fitCredits: { p95: rec.fitP95, max: rec.fitMax },
+      recommendedDeclaredHeadroomBps: terms.headroomBps,
+      feeBps: terms.feeBps,
+      usdCentsPerCredit: terms.usdCentsPerCredit,
+      missingTerms: rec.missingTerms,
+      costBasedMaxCredits: rec.costBasedMaxCredits,
+      lengthRaisedCeiling: rec.lengthRaisedCeiling,
       cutOffSamples: rec.cutOffSamples,
       exceedsStandCap: rec.exceedsStandCap,
       noRecommendationReason: rec.noRecommendationReason,
-      recommendedDeclaredHeadroomBps: headroomBps,
-      recommendedEstimateCoins: recommended,
-      recommendedPerCallMaxCoins: ceiling,
+      recommendedMaxCredits: rec.recommendedMaxCredits,
+      recommendedPerCallMaxCredits: rec.recommendedPerCallMaxCredits,
+      averageCreditsPerCall: rec.averageCreditsPerCall,
+      recommendedPerCallEstimateCredits: rec.recommendedPerCallEstimateCredits,
       savedTo
     });
     if (!ok) process.exitCode = 1;
     return;
   }
   log.plain("");
+  const printMeasured = () => {
+    log.plain(c.bold("  Real cost per call"));
+    log.plain(`    p50 ${usdFromPicos(rec.costP50)}   p95 ${usdFromPicos(rec.costP95)}   max ${usdFromPicos(rec.costMax)}   (${settledCount} of ${samples} settled)`);
+    log.plain(c.bold("  Charged credits"));
+    log.plain(`    p50 ${rec.chargedP50}   p95 ${rec.chargedP95}   max ${rec.chargedMax}   (whole credits, rounded up per call)`);
+  };
   if (lengthBlocked) {
-    if (charged.length > 0) {
-      log.plain(c.bold("  Charged coins"));
-      log.plain(`    p50 ${p50}   p95 ${p95}   max ${max}   (${charged.length} of ${samples} settled)`);
+    if (settledCount > 0) {
+      printMeasured();
       log.plain("");
     }
     printRecommendation(log, record);
@@ -24897,17 +25086,16 @@ async function runBench(args) {
     process.exitCode = 1;
     return;
   }
-  if (charged.length === 0) {
+  if (settledCount === 0) {
     log.error(
-      providerRefused > 0 && providerRefused === results.length ? "  No sample ran \u2014 the provider refused every attempt at its door \u2014 so there is nothing to price from." : "  No sample settled, so there is nothing to price from."
+      providerRefused > 0 && providerRefused === results.length ? "  No sample ran \u2014 the provider refused every attempt at its door \u2014 so there is nothing to measure from." : "  No sample settled, so there is nothing to measure from."
     );
     process.exitCode = 1;
     return;
   }
-  log.plain(c.bold("  Charged coins"));
-  log.plain(`    p50 ${p50}   p95 ${p95}   max ${max}   (${charged.length} of ${samples} settled)`);
+  printMeasured();
   if (balanceBefore !== null && balanceAfter !== null) {
-    log.plain(`    Balance ${balanceBefore} \u2192 ${balanceAfter} coin spendable`);
+    log.plain(`    Balance ${balanceBefore} \u2192 ${balanceAfter} credits spendable`);
   }
   log.plain("");
   printRecommendation(log, record);
@@ -24919,43 +25107,58 @@ function printRecommendation(log, record) {
     return;
   }
   if (record.noRecommendationReason === "answer_cut_off") {
-    log.warn(`  ${benchCutOffLine(record.cutOffSamples ?? 1, record.maxCoinsPerSample ?? 0)}`);
+    log.warn(`  ${benchCutOffLine(record.cutOffSamples || 1, record.maxCreditsPerSample)}`);
     return;
   }
-  if (record.recommendedEstimateCoins === null || record.p95 === null) {
-    log.warn("  No price recommended.");
+  const attempts = `${record.completed} settled attempt${record.completed === 1 ? "" : "s"} on ${record.modelId}`;
+  if (record.recommendedMaxCredits === null || record.cost.p95 === null) {
+    log.warn("  No ceiling 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"
+      record.cost.p95 === null ? "  No sample settled, so there is no p95 to build a ceiling on \u2014" : record.recommendedDeclaredHeadroomBps === null ? "  This stand served no recommended headroom, and the multiplier is the server's to set \u2014" : "  This stand served no platform fee or credit value, and those are the server's to set \u2014"
     );
     log.dim("  declaring a number from this run would be a guess dressed as a measurement.");
+    printAverage(log, record, attempts);
     return;
   }
-  log.plain(c.bold(`  Declare estimateCoins: ${record.recommendedEstimateCoins}`));
-  if (record.lengthRaisedPrice) {
+  log.plain(c.bold(`  Declare maxCredits: ${record.recommendedMaxCredits}`));
+  if (record.lengthRaisedCeiling) {
     log.plain(`  ${LLM_LENGTH_RAISED_LINE}`);
     log.dim(
-      `  = the smallest price whose answer allowance holds the answer plus this stand's headroom (p95 ${record.fitP95 ?? "\u2014"}), above the`
+      `  = the smallest ceiling whose answer allowance holds the answer plus this stand's headroom (p95 ${record.fitP95 ?? "\u2014"}), above the`
     );
     log.dim(
-      `  charged-based ${record.chargedBasedEstimateCoins ?? "\u2014"} (p95 of charged coins ${record.p95} plus ${record.recommendedDeclaredHeadroomBps} bps), over ${record.completed} settled attempt${record.completed === 1 ? "" : "s"} on ${record.modelId}.`
+      `  cost-based ${record.costBasedMaxCredits ?? "\u2014"} (p95 real cost ${usdFromPicos(record.cost.p95)} with the platform fee, ${record.feeBps} bps, and ${record.recommendedDeclaredHeadroomBps} bps of headroom), over ${attempts}.`
     );
   } else {
     log.dim(
-      `  = p95 of charged coins (${record.p95}) plus this stand's recommended headroom (${record.recommendedDeclaredHeadroomBps} bps),`
+      `  = p95 real cost (${usdFromPicos(record.cost.p95)}) with this stand's platform fee (${record.feeBps} bps) and recommended headroom (${record.recommendedDeclaredHeadroomBps} bps), in whole credits,`
     );
-    log.dim(`  measured over ${record.completed} settled attempt${record.completed === 1 ? "" : "s"} on ${record.modelId}.`);
+    log.dim(`  measured over ${attempts}.`);
   }
-  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("  That number is a CEILING, not a price: a call is billed its real cost as used, never more than it \u2014");
+  log.dim("  and it also sizes how long the answer may be.");
+  if (record.recommendedPerCallMaxCredits !== null) {
+    log.plain(c.bold(`  Grant perCallMaxCredits: ${record.recommendedPerCallMaxCredits}`));
     log.dim(
-      record.lengthRaisedPrice ? `  = the same headroom over the worst sample (${record.max}) or the longest answer's price, whichever is larger, and never below the price above it.` : `  = the same headroom over the worst sample (${record.max}), and never below the price above it.`
+      record.lengthRaisedCeiling ? `  = the same over the worst sample (${usdFromPicos(record.cost.max)}) or the longest answer's ceiling, whichever is larger, and never below the ceiling above it.` : `  = the same over the worst sample (${usdFromPicos(record.cost.max)}), and never below the ceiling above it.`
     );
-    log.dim("  The ceiling is the price's room to be wrong; declaring one under the price is refused.");
+  }
+  printAverage(log, record, attempts);
+}
+function printAverage(log, record, attempts) {
+  if (record.averageCreditsPerCall === null) return;
+  log.plain(`  Per-call estimate: about ${formatCredits(record.averageCreditsPerCall)} credits per call`);
+  log.dim(`  = the average real cost with the platform fee, no headroom, over ${attempts}.`);
+  if (record.recommendedPerCallEstimateCredits !== null) {
+    log.plain(c.bold(`  Grant perCallEstimateCredits: ${record.recommendedPerCallEstimateCredits}`));
+    log.dim(`  = that average rounded up to a whole credit. disclosure.estimatedCreditsPerPeriod = your calls per period \xD7 ${formatCredits(record.averageCreditsPerCall)}, rounded up.`);
   }
 }
 async function explainBenchRefusal(res, call2, base, log, opts, index, settledSoFar) {
-  if (printedStructuredError(res)) return { stop: true, refusal: { status: res.status, error: null, slotsHeld: null, slotLimit: null } };
+  if (printedStructuredError(res)) {
+    const printed = await res.json().catch(() => ({}));
+    return { stop: true, refusal: { status: res.status, error: typeof printed.error === "string" ? printed.error : null, slotsHeld: null, slotLimit: null } };
+  }
   const body = await res.json().catch(() => ({}));
   const refusal2 = { status: res.status, error: body.error ?? null, slotsHeld: null, slotLimit: null };
   if (res.status === 429 && body.error === "generation_limit") {
@@ -24965,6 +25168,10 @@ async function explainBenchRefusal(res, call2, base, log, opts, index, settledSo
     if (!opts.json) log.error(`  Sample ${index + 1} ${benchSlotsHeldSentence(counts)}`);
     return { stop: true, refusal: refusal2 };
   }
+  if (res.status === 403 && body.error === "credits_unverified") {
+    if (!opts.json) log.error(`  ${LLM_BENCH_UNVERIFIED_LINE}`);
+    return { stop: true, refusal: refusal2 };
+  }
   if (opts.json) return { stop: res.status !== 429, refusal: refusal2 };
   if (res.status === 404 && body.error === "not_found") {
     log.error(`  ${LLM_LANE_OFF_LINE}`);
@@ -24980,7 +25187,7 @@ async function explainBenchRefusal(res, call2, base, log, opts, index, settledSo
     return { stop: true, refusal: refusal2 };
   }
   if (res.status === 402) {
-    log.error("  Not enough coin to start the attempt.");
+    log.error("  Not enough credits to start the attempt \u2014 a bench is paid from your own balance.");
     return { stop: true, refusal: refusal2 };
   }
   log.error(
@@ -24989,7 +25196,7 @@ async function explainBenchRefusal(res, call2, base, log, opts, index, settledSo
   return { stop: res.status >= 500 || res.status === 401 || res.status === 403, refusal: refusal2 };
 }
 function printProviderRefusal(log, status2, message, awaitingBill = false) {
-  if (awaitingBill) log.dim(`      The provider answered ${status2} after routing \u2014 its bill is not final, so this call's coin stays held until it resolves (see \`genex llm status\`); it is not a sample.`);
+  if (awaitingBill) log.dim(`      The provider answered ${status2} after routing \u2014 its bill is not final, so what this call reserved stays held until it resolves (see \`genex llm status\`); it is not a sample.`);
   else log.dim("      The provider refused this call at its door \u2014 no inference ran, it cost nothing, and it is not a sample.");
   if (message) log.dim(`      Provider said: ${message}`);
   if (status2 === 401 || status2 === 403) {
@@ -25015,19 +25222,6 @@ async function pollSettled(call2, url, timeoutSec) {
   }
   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 = path36.join(cwd, LLM_BENCH_FILE);
@@ -25043,9 +25237,10 @@ function benchFailed(opts, log, message) {
   else log.error(message);
   process.exitCode = 1;
 }
-function emptyBenchJson(apiUrl, projectId, prompt, outputFormat, samples, maxCoins, opts) {
+function emptyBenchJson(apiUrl, projectId, prompt, outputFormat, samples, maxCredits, opts) {
   return {
     command: "llm bench",
+    currency: "credits",
     apiUrl,
     projectId,
     modelId: opts.modelId ?? null,
@@ -25054,21 +25249,28 @@ function emptyBenchJson(apiUrl, projectId, prompt, outputFormat, samples, maxCoi
     schemaPath: opts.schemaPath ?? null,
     samples,
     completed: 0,
-    maxCoinsPerSample: maxCoins,
+    maxCreditsPerSample: maxCredits,
     balanceBefore: null,
     balanceAfter: null,
     results: [],
     refusal: null,
-    chargedCoins: { p50: null, p95: null, max: null },
-    fitCoins: { p95: null, max: null },
-    chargedBasedEstimateCoins: null,
-    lengthRaisedPrice: false,
+    costUsdPicos: { p50: null, p95: null, max: null },
+    costUsd: { p50: null, p95: null, max: null },
+    chargedCredits: { p50: null, p95: null, max: null },
+    fitCredits: { p95: null, max: null },
+    recommendedDeclaredHeadroomBps: null,
+    feeBps: null,
+    usdCentsPerCredit: null,
+    missingTerms: null,
+    costBasedMaxCredits: null,
+    lengthRaisedCeiling: false,
     cutOffSamples: 0,
     exceedsStandCap: false,
     noRecommendationReason: null,
-    recommendedDeclaredHeadroomBps: null,
-    recommendedEstimateCoins: null,
-    recommendedPerCallMaxCoins: null,
+    recommendedMaxCredits: null,
+    recommendedPerCallMaxCredits: null,
+    averageCreditsPerCall: null,
+    recommendedPerCallEstimateCredits: null,
     savedTo: null
   };
 }
@@ -25131,7 +25333,8 @@ async function reportStatus(args) {
     for (const row of rows) {
       const state = rowState(row);
       const mark = state === "active" ? c.cyan("\u25CF") : state === "awaiting bill" ? c.yellow("\u25D0") : c.green("\u25CB");
-      const reserved = typeof row.reservedCoins === "number" ? `${row.reservedCoins} coin reserved` : "reserved \u2014";
+      const money2 = rowMoney(row);
+      const reserved = money2.reserved === null ? "reserved \u2014" : `${money2.reserved} ${money2.unit} reserved`;
       log.plain(
         `  ${mark} ${row.id ?? "?"}  ${row.modelId ?? "?"}  ${state.padEnd(13)}  ${formatAge(row.createdAt, now).padStart(4)} old  ${reserved}${row.error ? `  ${row.error}` : ""}${rowHoldsSlot(row) ? "" : c.dim("  (no slot)")}`
       );
@@ -25203,10 +25406,11 @@ async function cancelCall(args) {
     if (!opts.json) {
       log.warn(`  ${row.id} (${row.status ?? "?"}) \u2014 ${sentence}.`);
       if (state === "awaiting bill") {
-        log.dim(`  Nothing to cancel: its coin releases when the bill resolves, and it stops holding a slot ${PENDING_SLOT_RELEASE_MINUTES} minutes after dispatch.`);
+        log.dim(`  Nothing to cancel: what it reserved releases when the bill resolves, and it stops holding a slot ${PENDING_SLOT_RELEASE_MINUTES} minutes after dispatch.`);
         if (row.providerMessage?.trim()) log.dim(`  Provider said: ${row.providerMessage.trim()}`);
       } else {
-        log.dim(`  ${typeof row.chargedCoins === "number" ? `${row.chargedCoins} coin charged` : "charge unknown"}${row.error ? ` \xB7 ${row.error}` : ""}.`);
+        const money2 = rowMoney(row);
+        log.dim(`  ${money2.charged === null ? "charge unknown" : `${money2.charged} ${money2.unit} charged`}${row.error ? ` \xB7 ${row.error}` : ""}.`);
       }
     }
     return done("ok", null, state === "awaiting bill" ? "awaiting_bill" : "already_final", row);
@@ -25228,78 +25432,126 @@ async function cancelCall(args) {
   const after = await res.json().catch(() => null) ?? row;
   if (!opts.json) {
     log.success(`  Cancelled ${row.id} (was ${row.status ?? "active"}).`);
-    log.dim(`  Its coin releases once the bill settles; ${c.cyan("genex llm status")} shows it until then.`);
+    log.dim(`  What it reserved releases once the bill settles; ${c.cyan("genex llm status")} shows it until then.`);
   }
   return done("ok", null, "cancelled", after);
 }
-async function reportSavedPrice(cwd, opts, log) {
-  let record = null;
+async function readSavedBench(cwd) {
+  let parsed;
   try {
-    record = JSON.parse(await fs35.readFile(path36.join(cwd, LLM_BENCH_FILE), "utf8"));
+    parsed = JSON.parse(await fs35.readFile(path36.join(cwd, LLM_BENCH_FILE), "utf8"));
   } catch {
-    record = null;
+    return null;
   }
-  if (!record) {
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+  const v = parsed;
+  if (v.v === 2 && v.currency === "credits" && v.cost && v.charged) return { kind: "credits", record: parsed };
+  return { kind: "coins", record: parsed };
+}
+var LLM_PRICE_COIN_TERMS_LINE = "This bench was measured under the old COIN terms, when a game declared a fixed price per call. In-game calls are now billed in the player's credits, as used, and a game declares a per-call CEILING (maxCredits) instead \u2014 a coin price is not that number. Re-run the bench for the figures to declare.";
+async function reportSavedPrice(cwd, opts, log) {
+  const saved = await readSavedBench(cwd);
+  const rerun = 'genex llm bench "<prompt>" --max-credits <n> --user-approved';
+  const creditKeys = (record2) => ({
+    costUsdPicos: record2?.cost ?? { p50: null, p95: null, max: null },
+    chargedCredits: record2?.charged ?? { p50: null, p95: null, max: null },
+    fitP95: record2?.fitP95 ?? null,
+    fitMax: record2?.fitMax ?? null,
+    recommendedDeclaredHeadroomBps: record2?.recommendedDeclaredHeadroomBps ?? null,
+    feeBps: record2?.feeBps ?? null,
+    usdCentsPerCredit: record2?.usdCentsPerCredit ?? null,
+    costBasedMaxCredits: record2?.costBasedMaxCredits ?? null,
+    lengthRaisedCeiling: record2?.lengthRaisedCeiling ?? false,
+    cutOffSamples: record2?.cutOffSamples ?? 0,
+    noRecommendationReason: record2?.noRecommendationReason ?? null,
+    recommendedMaxCredits: record2?.recommendedMaxCredits ?? null,
+    recommendedPerCallMaxCredits: record2?.recommendedPerCallMaxCredits ?? null,
+    averageCreditsPerCall: record2?.averageCreditsPerCall ?? null,
+    recommendedPerCallEstimateCredits: record2?.recommendedPerCallEstimateCredits ?? null
+  });
+  if (!saved) {
     if (opts.json) {
       writeJsonLine({
         command: "llm price",
         status: "failed",
         error: "no_bench",
+        currency: null,
         ranAt: null,
         modelId: null,
         samples: null,
         completed: null,
-        p50: null,
-        p95: null,
-        max: null,
-        fitP95: null,
-        chargedBasedEstimateCoins: null,
-        lengthRaisedPrice: false,
-        cutOffSamples: 0,
-        noRecommendationReason: null,
-        recommendedDeclaredHeadroomBps: null,
-        recommendedEstimateCoins: null,
-        recommendedPerCallMaxCoins: null,
+        ...creditKeys(null),
+        legacyCoinTerms: 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.`);
+      log.dim(`  Run ${c.cyan(rerun)} first.`);
+    }
+    process.exitCode = 1;
+    return;
+  }
+  if (saved.kind === "coins") {
+    const old = saved.record;
+    const legacy = {
+      p50: old.p50 ?? null,
+      p95: old.p95 ?? null,
+      max: old.max ?? null,
+      recommendedEstimateCoins: old.recommendedEstimateCoins ?? null,
+      recommendedPerCallMaxCoins: old.recommendedPerCallMaxCoins ?? null,
+      maxCoinsPerSample: old.maxCoinsPerSample ?? null,
+      noRecommendationReason: old.noRecommendationReason ?? null
+    };
+    if (opts.json) {
+      writeJsonLine({
+        command: "llm price",
+        status: "failed",
+        error: "coin_terms",
+        currency: "coins",
+        ranAt: old.ranAt ?? null,
+        modelId: old.modelId ?? null,
+        samples: old.samples ?? null,
+        completed: old.completed ?? null,
+        ...creditKeys(null),
+        legacyCoinTerms: legacy,
+        savedTo: LLM_BENCH_FILE
+      });
+    } else {
+      log.plain(c.bold("genex llm price"));
+      log.dim(`  from ${LLM_BENCH_FILE}, benchmarked ${old.ranAt ?? "at an unknown time"}${old.modelId ? ` on ${old.modelId}` : ""}`);
+      log.plain("");
+      log.warn(`  ${LLM_PRICE_COIN_TERMS_LINE}`);
+      const measured = legacy.p95 === null ? "no settled sample" : `charged coins p50 ${legacy.p50} \xB7 p95 ${legacy.p95} \xB7 max ${legacy.max}`;
+      const recommended = legacy.recommendedEstimateCoins === null ? "no price recommended" : `it recommended estimateCoins ${legacy.recommendedEstimateCoins}${legacy.recommendedPerCallMaxCoins != null ? ` and perCallMaxCoins ${legacy.recommendedPerCallMaxCoins}` : ""}`;
+      log.dim(`  What it measured then: ${measured}; ${recommended}.`);
+      log.dim(`  Re-run: ${c.cyan(rerun)}`);
     }
     process.exitCode = 1;
     return;
   }
+  const record = saved.record;
   if (opts.json) {
     writeJsonLine({
       command: "llm price",
-      status: record.recommendedEstimateCoins === null ? "failed" : "ok",
-      error: record.recommendedEstimateCoins === null ? record.noRecommendationReason ?? "no_recommendation" : null,
+      status: record.recommendedMaxCredits === null ? "failed" : "ok",
+      error: record.recommendedMaxCredits === null ? record.noRecommendationReason ?? "no_recommendation" : null,
+      currency: "credits",
       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,
-      // Absent from a file an older CLI wrote; null / false / 0 then, never missing.
-      fitP95: record.fitP95 ?? null,
-      chargedBasedEstimateCoins: record.chargedBasedEstimateCoins ?? null,
-      lengthRaisedPrice: record.lengthRaisedPrice ?? false,
-      cutOffSamples: record.cutOffSamples ?? 0,
-      noRecommendationReason: record.noRecommendationReason ?? null,
-      recommendedDeclaredHeadroomBps: record.recommendedDeclaredHeadroomBps ?? null,
-      recommendedEstimateCoins: record.recommendedEstimateCoins ?? null,
-      recommendedPerCallMaxCoins: record.recommendedPerCallMaxCoins ?? null,
+      ...creditKeys(record),
+      legacyCoinTerms: null,
       savedTo: LLM_BENCH_FILE
     });
-    if (record.recommendedEstimateCoins === null) process.exitCode = 1;
+    if (record.recommendedMaxCredits === 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;
+  if (record.recommendedMaxCredits === null) process.exitCode = 1;
 }
 function writeJsonLine(value) {
   process.stdout.write(`${JSON.stringify(value)}
@@ -25559,7 +25811,7 @@ function runtimeRow(state, lane, toolsOnly = false) {
       return {
         label: "Runtime",
         value: `in-game LLM lane live \xB7 ${n} model${n === 1 ? "" : "s"}${keyRefused ? ` \xB7 ${c.yellow("provider key refused")}` : ""}`,
-        fix: keyRefused ? LLM_PROVIDER_KEY_REJECTED_LINE : toolsOnly ? convertFix : 'Price a call before a game declares one: `npx genex llm bench "<prompt>" --max-coins <n> --user-approved`.'
+        fix: keyRefused ? LLM_PROVIDER_KEY_REJECTED_LINE : toolsOnly ? convertFix : 'Measure a call before a game declares its per-call ceiling: `npx genex llm bench "<prompt>" --max-credits <n> --user-approved`.'
       };
     }
     case "off":
@@ -28236,16 +28488,16 @@ ${c.bold("Usage")}
                                      status | cancel. "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>
+                                     model on YOUR OWN credits and reports what each
+                                     attempt really cost; it needs --max-credits <n>
                                      --user-approved, like any spend the player has
                                      to agree to. "price" reprints the last run's
-                                     recommended estimateCoins. "status" lists this
+                                     recommended maxCredits. "status" lists this
                                      project's open calls and the slots they hold;
                                      "cancel <id>" stops an active one. Declare a
-                                     game's price from a bench, never from a guess:
-                                     a started attempt is charged in full, including
-                                     one that fails.
+                                     game's per-call ceiling from a bench, never
+                                     from a guess: the player is billed as used, and
+                                     the ceiling also sizes how long an answer may be.
   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
@@ -28712,7 +28964,7 @@ ${c.bold("Examples")}
   genex shop remove sku_123
   genex llm models
   genex llm models --all
-  genex llm bench "Reply with one short taunt." --samples 5 --max-coins 20 --user-approved
+  genex llm bench "Reply with one short taunt." --samples 5 --max-credits 20 --user-approved
   genex llm price
   genex llm status
   genex llm cancel <id>
@@ -28949,22 +29201,24 @@ ${c.bold("How the allowance works")}
 
   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?
+  llm: `${c.bold("genex llm")} \u2014 in-game model calls: is the lane live, what does one call cost, what ceiling should the game declare?
 
 ${c.bold("Usage")}
   genex llm models [--all] [--json]  Which models this stand serves, their provider rates per
-                                     million tokens, and the headroom it recommends over a
-                                     benchmark. The catalog is synced from OpenRouter, so the
-                                     FEATURED short list is printed by default and --all
-                                     prints every row (--json always carries every row). 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.
+                                     million tokens, the platform fee a call is billed at, and
+                                     the headroom it recommends over a benchmark. The catalog
+                                     is synced from OpenRouter, so the FEATURED short list is
+                                     printed by default and --all prints every row (--json
+                                     always carries every row). 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-credits <n> --user-approved [options]
+                                     Run the real model through the development lane and
+                                     report what each attempt really COST and was charged.
+                                     Refused without both flags, before any network call:
+                                     this spends YOUR OWN CREDITS, a spend the build's asset
+                                     allowance does not count. Needs a folder linked to a
+                                     game you own, and a balance that covers one attempt.
   genex llm price [--json]           The recommendation from the last bench in this folder.
                                      Reads a file; spends nothing.
   genex llm status [--json]          This project's open development calls: active, or
@@ -28981,29 +29235,32 @@ ${c.bold("Bench options")}
   --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,
+  --max-credits <n>    The per-attempt ceiling YOU approved \u2014 a bench runs on your own credits,
                        never a player's. The run's worst case is that number times --samples,
-                       and it is printed before anything starts.
+                       and it is printed before anything starts. (--max-coins is its deprecated
+                       name, read as the same number.)
   --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.
+  An in-game call is paid from the PLAYER's credits and billed as used: its real provider cost
+  plus the platform fee, never more than the per-call CEILING the game declares (\`maxCredits\`,
+  or \`perCallMaxCredits\` on a standing budget). The ceiling is not a price, but it is still a
+  number with two jobs: it bounds what one call may cost, and it funds how LONG the answer may
+  be. Three layers sit between the provider's rate card and it \u2014 the provider's cost for YOUR
+  prompt, the platform fee, and your headroom \u2014 and only a real call measures the first. The
+  bench is billed to YOU, on the development lane; the player-funded lane is what the
+  published game uses. The recommendation is the p95 real cost with the server's fee and
+  headroom applied, in whole credits; a stand that serves no headroom or no fee gets no
+  recommendation, because those multipliers are not the CLI's to invent.
 
-  The declared price also decides how LONG the answer may be: it sizes each call's output
-  allowance. So the recommendation is never below the smallest price that leaves room for
-  the benchmarked answer, as the server computes it. A sample cut off at your --max-coins
-  (provider_token_limit) is not a sample \u2014 re-run with a higher --max-coins; an answer longer
-  than one call on this stand may produce gets no price at all \u2014 ask for a shorter one.
+  Because the ceiling sizes each call's output allowance, the recommendation is never below
+  the smallest ceiling that leaves room for the benchmarked answer, as the server computes it.
+  A sample cut off at your --max-credits (provider_token_limit) is not a sample \u2014 re-run with a
+  higher --max-credits; an answer longer than one call on this stand may produce gets no
+  ceiling at all \u2014 ask for a shorter one. The run also prints the measured average per call,
+  fee included, which is the honest estimate a budget's disclosure is built on.
 
   Results land in ${LLM_BENCH_FILE} \u2014 gitignored, machine-local, re-read by \`genex llm price\`.
 `,
@@ -29251,11 +29508,13 @@ 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).
+    // `genex llm bench` value flags. `--max-credits` is the same approval
+    // shape as `--assets`, but its own gate: the asset allowance does not
+    // count a bench. `--max-coins` is its deprecated name (same number).
     "--model",
     "--samples",
     "--schema",
+    "--max-credits",
     "--max-coins",
     // `genex player install --label <name>` — what this machine is called in
     // the dashboard. Its own key rather than the generic 2nd positional,
@@ -29809,12 +30068,14 @@ function applyValueFlag(options, flag, value) {
       options.samples = n;
       break;
     }
+    case "--max-credits":
     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)`);
+        throw new Error(`Invalid ${flag} value: ${value} (whole credits, 1 or more)`);
       }
-      options.maxCoins = n;
+      if (flag === "--max-credits") options.maxCredits = n;
+      else options.maxCoins = n;
       break;
     }
     case "--timeout": {
@@ -30112,9 +30373,9 @@ async function main() {
         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.
+      // cost, what ceiling should the game declare. `bench` spends the
+      // builder's own credits OUTSIDE the asset allowance, so it carries its
+      // own --max-credits/--user-approved gate.
       case "llm":
         await runLlm(parsed.options);
         break;