@homie-rocks/studio 0.21.0 → 0.22.0

package/assets/safety.mjs

@@ -0,0 +1,194 @@
+/**
+ * IS THIS MODEL FILE SAFE TO LOAD? One answer for every place a model enters a game: the browser loader
+ * (assets/assets.ts, before three.js parses a byte), `homie-studio assets add` and `assets check` (Node), and the
+ * starter library's build. Plain JavaScript with no imports, so a browser bundle and Node read the same rules.
+ *
+ * A model is a glTF 2.0 binary (.glb): a 12-byte header, a JSON chunk and one binary chunk. It is refused when:
+ *   - it is not a GLB (a bare .gltf names its buffers and pictures by address: that is an external file);
+ *   - any buffer or picture names a `uri` other than a small `data:` one (an external URI could be fetched from
+ *     anywhere, at any size, by every player's browser);
+ *   - the file, its declared buffers, a buffer view or an accessor is bigger than the limits (a 200 MB buffer would
+ *     take a phone's whole page memory before anything checked it), or an accessor reaches past its buffer;
+ *   - it requires an extension three.js cannot read, or names more meshes, nodes, pictures or animations than any
+ *     game asset needs.
+ * Warnings (extensions used but not required, a picture type a phone may not decode) never refuse.
+ */
+
+/** The limits, in bytes and counts: `LIMITS.game` for a shipped asset, `LIMITS.import` for a raw file coming in. */
+export const LIMITS = Object.freeze({
+  game: Object.freeze({ bytes: 5 * 1024 * 1024, json: 2 * 1024 * 1024, buffer: 5 * 1024 * 1024, dataUri: 256 * 1024, vertices: 500_000, meshes: 512, nodes: 4096, materials: 64, images: 32, textures: 64, animations: 256, skins: 16, accessors: 8192 }),
+  import: Object.freeze({ bytes: 64 * 1024 * 1024, json: 8 * 1024 * 1024, buffer: 64 * 1024 * 1024, dataUri: 1024 * 1024, vertices: 4_000_000, meshes: 4096, nodes: 16384, materials: 256, images: 128, textures: 256, animations: 1024, skins: 64, accessors: 32768 }),
+});
+
+/** Extensions three.js's GLTFLoader reads (r185). A file that REQUIRES any other is refused. */
+export const READABLE_EXTENSIONS = Object.freeze([
+  'KHR_meshopt_compression', 'EXT_meshopt_compression', 'KHR_mesh_quantization', 'KHR_texture_basisu', 'EXT_texture_webp',
+  'EXT_texture_avif', 'KHR_texture_transform', 'KHR_materials_unlit', 'KHR_materials_emissive_strength', 'KHR_materials_clearcoat',
+  'KHR_materials_ior', 'KHR_materials_specular', 'KHR_materials_transmission', 'KHR_materials_volume', 'KHR_materials_sheen',
+  'KHR_materials_iridescence', 'KHR_materials_anisotropy', 'KHR_materials_dispersion', 'KHR_lights_punctual', 'EXT_mesh_gpu_instancing',
+  'KHR_draco_mesh_compression',
+]);
+
+const PICTURE_TYPES = ['image/png', 'image/jpeg', 'image/webp', 'image/ktx2', 'image/avif'];
+const COMPONENT_BYTES = { 5120: 1, 5121: 1, 5122: 2, 5123: 2, 5125: 4, 5126: 4 };
+const TYPE_SIZE = { SCALAR: 1, VEC2: 2, VEC3: 3, VEC4: 4, MAT2: 4, MAT3: 9, MAT4: 16 };
+const MAGIC = 0x46546c67; // "glTF"
+const JSON_CHUNK = 0x4e4f534a;
+const BIN_CHUNK = 0x004e4942;
+
+const view = (bytes) => new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+const size = (n) => (n >= 1024 * 1024 ? `${(n / 1024 / 1024).toFixed(1)} MB` : `${Math.ceil(n / 1024)} KB`);
+
+/** The bytes a `data:` URI decodes to, without decoding it. */
+function dataUriBytes(uri) {
+  const comma = uri.indexOf(',');
+  if (comma < 0) return Infinity;
+  const head = uri.slice(5, comma);
+  const body = uri.length - comma - 1;
+  return /;base64$/i.test(head) ? Math.floor((body * 3) / 4) : body;
+}
+
+/**
+ * Read a GLB's header and chunks: { json, bin: { offset, length } | null } or throws a plain-words Error.
+ * `bytes` is a Uint8Array (a Node Buffer is one).
+ */
+export function readGlb(bytes, { maxJson = LIMITS.import.json } = {}) {
+  if (!(bytes instanceof Uint8Array)) throw new Error('not a file (expected bytes)');
+  if (bytes.byteLength < 20) throw new Error('too short to be a glTF binary (.glb)');
+  const dv = view(bytes);
+  if (dv.getUint32(0, true) !== MAGIC) {
+    const head = new TextDecoder().decode(bytes.subarray(0, Math.min(64, bytes.byteLength))).trimStart();
+    throw new Error(head.startsWith('{') ? 'a .gltf with separate files (its buffers and pictures are loaded by address): only a self-contained .glb is loaded' : 'not a glTF binary (.glb)');
+  }
+  const version = dv.getUint32(4, true);
+  if (version !== 2) throw new Error(`glTF version ${version} (only 2 is read)`);
+  const length = dv.getUint32(8, true);
+  if (length > bytes.byteLength) throw new Error(`the header says ${size(length)} but the file has ${size(bytes.byteLength)}: it is cut short`);
+  let at = 12;
+  let json = null;
+  let bin = null;
+  while (at + 8 <= length) {
+    const chunkLength = dv.getUint32(at, true);
+    const type = dv.getUint32(at + 4, true);
+    const start = at + 8;
+    if (start + chunkLength > length) throw new Error('a chunk runs past the end of the file');
+    if (type === JSON_CHUNK && json === null) {
+      if (chunkLength > maxJson) throw new Error(`its JSON is ${size(chunkLength)}, over ${size(maxJson)}`);
+      try { json = JSON.parse(new TextDecoder().decode(bytes.subarray(start, start + chunkLength))); } catch { throw new Error('its JSON chunk is not JSON'); }
+    } else if (type === BIN_CHUNK && bin === null) bin = { offset: start, length: chunkLength };
+    at = start + chunkLength + ((4 - (chunkLength % 4)) % 4);
+  }
+  if (!json || typeof json !== 'object') throw new Error('it has no JSON chunk');
+  return { json, bin, length };
+}
+
+/**
+ * Check a GLB against `limits` (LIMITS.game by default). Returns
+ *   { ok, problems: [plain words], warnings: [plain words], info: { bytes, triangles, vertices, meshes, nodes,
+ *     materials, images, textures, animations, skins, joints, extensions: { used, required } } }
+ * Never throws: a file it cannot read is `ok: false` with the reason.
+ */
+export function checkGlb(bytes, limits = LIMITS.game) {
+  const L = { ...LIMITS.game, ...limits };
+  const problems = [];
+  const warnings = [];
+  const info = { bytes: bytes?.byteLength ?? 0, triangles: 0, vertices: 0, meshes: 0, nodes: 0, materials: 0, images: 0, textures: 0, animations: 0, skins: 0, joints: 0, extensions: { used: [], required: [] } };
+  if (info.bytes > L.bytes) problems.push(`the file is ${size(info.bytes)}, over the ${size(L.bytes)} a model may be here`);
+  let glb;
+  try { glb = readGlb(bytes, { maxJson: L.json }); } catch (error) { problems.push(error.message); return { ok: false, problems, warnings, info }; }
+  const j = glb.json;
+  const arr = (k) => (Array.isArray(j[k]) ? j[k] : []);
+  const v = String(j.asset?.version ?? '');
+  if (!/^2\./.test(v)) problems.push(`asset.version is "${v || 'missing'}" (glTF 2.x is read)`);
+
+  // Counts.
+  const counts = { meshes: arr('meshes').length, nodes: arr('nodes').length, materials: arr('materials').length, images: arr('images').length, textures: arr('textures').length, animations: arr('animations').length, skins: arr('skins').length, accessors: arr('accessors').length };
+  Object.assign(info, { meshes: counts.meshes, nodes: counts.nodes, materials: counts.materials, images: counts.images, textures: counts.textures, animations: counts.animations, skins: counts.skins });
+  for (const [k, n] of Object.entries(counts)) if (L[k] !== undefined && n > L[k]) problems.push(`${n} ${k} (at most ${L[k]})`);
+
+  // Extensions.
+  const used = arr('extensionsUsed').map(String);
+  const required = arr('extensionsRequired').map(String);
+  info.extensions = { used, required };
+  for (const e of required) if (!READABLE_EXTENSIONS.includes(e)) problems.push(`it requires the extension ${e}, which three.js cannot read`);
+  for (const e of used) if (!required.includes(e) && !READABLE_EXTENSIONS.includes(e)) warnings.push(`it uses ${e}, which three.js ignores`);
+  if (required.includes('KHR_draco_mesh_compression')) warnings.push('Draco geometry: the decoder is about 250 KB more to download; meshopt is the house format');
+
+  // Buffers: only the GLB's own binary chunk, or a small data: URI. Never an address.
+  let declared = 0;
+  arr('buffers').forEach((b, i) => {
+    const len = Number(b?.byteLength);
+    if (!Number.isFinite(len) || len < 0) { problems.push(`buffer ${i} has no byteLength`); return; }
+    // A meshopt fallback buffer (no uri, never loaded by a reader that decodes meshopt) holds nothing in the file.
+    const fallback = b.uri === undefined && (b.extensions?.EXT_meshopt_compression?.fallback === true || b.extensions?.KHR_meshopt_compression?.fallback === true);
+    if (fallback) { if (len > L.buffer * 4) problems.push(`buffer ${i} (a meshopt fallback) declares ${size(len)}`); return; }
+    declared += len;
+    if (len > L.buffer) problems.push(`buffer ${i} declares ${size(len)}, over ${size(L.buffer)}`);
+    if (typeof b.uri === 'string') {
+      if (!/^data:/i.test(b.uri)) problems.push(`buffer ${i} is loaded from an address (${b.uri.slice(0, 60)}): an external URI`);
+      else if (dataUriBytes(b.uri) > L.dataUri) problems.push(`buffer ${i} is a data: URI of ${size(dataUriBytes(b.uri))}, over ${size(L.dataUri)}`);
+    } else if (i === 0) {
+      if (!glb.bin) problems.push('buffer 0 has no binary chunk to point at');
+      else if (len > glb.bin.length) problems.push(`buffer 0 declares ${size(len)} but the binary chunk holds ${size(glb.bin.length)}`);
+    } else problems.push(`buffer ${i} has no uri and is not the binary chunk`);
+  });
+  if (declared > L.bytes) problems.push(`its buffers declare ${size(declared)} in all, over ${size(L.bytes)}`);
+  const bufLen = (i) => Number(arr('buffers')[i]?.byteLength ?? -1);
+
+  // Buffer views and accessors stay inside what was declared.
+  const views = arr('bufferViews');
+  views.forEach((bv, i) => {
+    const end = Number(bv?.byteOffset ?? 0) + Number(bv?.byteLength ?? NaN);
+    if (!Number.isFinite(end) || bufLen(Number(bv?.buffer)) < 0 || end > bufLen(Number(bv.buffer))) problems.push(`buffer view ${i} reaches past its buffer`);
+  });
+  let maxCount = 0;
+  arr('accessors').forEach((a, i) => {
+    const count = Number(a?.count);
+    if (!Number.isInteger(count) || count < 0) { problems.push(`accessor ${i} has no count`); return; }
+    maxCount = Math.max(maxCount, count);
+    if (count > L.vertices * 3) problems.push(`accessor ${i} holds ${count.toLocaleString('en-US')} elements`);
+    if (a.bufferView === undefined) return;
+    const bv = views[Number(a.bufferView)];
+    const el = (COMPONENT_BYTES[a.componentType] ?? 0) * (TYPE_SIZE[a.type] ?? 0);
+    if (!bv || !el) { problems.push(`accessor ${i} points at nothing it can read`); return; }
+    const stride = Number(bv.byteStride ?? 0) || el;
+    const need = Number(a.byteOffset ?? 0) + (count ? stride * (count - 1) + el : 0);
+    // A meshopt-compressed view holds its decoded size in its extension; the plain view is the fallback.
+    const decoded = Number(bv.extensions?.EXT_meshopt_compression?.byteLength ?? bv.extensions?.KHR_meshopt_compression?.byteLength ?? bv.byteLength);
+    if (need > Math.max(Number(bv.byteLength), decoded)) problems.push(`accessor ${i} reaches past its buffer view`);
+  });
+
+  // Pictures: inside the file (a buffer view), or a small data: URI. Never an address.
+  arr('images').forEach((im, i) => {
+    if (typeof im?.uri === 'string') {
+      if (!/^data:/i.test(im.uri)) problems.push(`picture ${i} is loaded from an address (${im.uri.slice(0, 60)}): an external URI`);
+      else if (dataUriBytes(im.uri) > L.dataUri) problems.push(`picture ${i} is a data: URI of ${size(dataUriBytes(im.uri))}, over ${size(L.dataUri)}`);
+    } else if (im?.bufferView === undefined) problems.push(`picture ${i} has neither a buffer view nor a uri`);
+    const type = String(im?.mimeType ?? (typeof im?.uri === 'string' ? /^data:([^;,]+)/.exec(im.uri)?.[1] ?? '' : ''));
+    if (type && !PICTURE_TYPES.includes(type)) warnings.push(`picture ${i} is ${type}`);
+  });
+
+  // Triangles and vertices, as drawn: each mesh times the nodes that place it (GPU instancing counted once per node).
+  const accessors = arr('accessors');
+  const meshTris = arr('meshes').map((m) => (Array.isArray(m?.primitives) ? m.primitives : []).reduce((n, p) => {
+    const mode = p?.mode ?? 4;
+    const count = p?.indices !== undefined ? Number(accessors[p.indices]?.count ?? 0) : Number(accessors[p?.attributes?.POSITION]?.count ?? 0);
+    return n + (mode === 4 ? Math.floor(count / 3) : mode === 5 || mode === 6 ? Math.max(0, count - 2) : 0);
+  }, 0));
+  const meshVerts = arr('meshes').map((m) => (Array.isArray(m?.primitives) ? m.primitives : []).reduce((n, p) => n + Number(accessors[p?.attributes?.POSITION]?.count ?? 0), 0));
+  for (const node of arr('nodes')) {
+    if (node?.mesh === undefined) continue;
+    const inst = Number(accessors[node.extensions?.EXT_mesh_gpu_instancing?.attributes?.TRANSLATION]?.count ?? 1) || 1;
+    info.triangles += (meshTris[node.mesh] ?? 0) * inst;
+    info.vertices += (meshVerts[node.mesh] ?? 0) * inst;
+  }
+  info.joints = arr('skins').reduce((n, s) => Math.max(n, Array.isArray(s?.joints) ? s.joints.length : 0), 0);
+  if (info.vertices > L.vertices) problems.push(`${info.vertices.toLocaleString('en-US')} vertices drawn (at most ${L.vertices.toLocaleString('en-US')})`);
+  void maxCount;
+  return { ok: problems.length === 0, problems, warnings, info };
+}
+
+/** One line for a refusal: "refused <label>: a; b". */
+export function refusal(label, result) {
+  return `refused ${label}: ${result.problems.slice(0, 4).join('; ')}${result.problems.length > 4 ? `; and ${result.problems.length - 4} more` : ''}`;
+}

package/bin/homie-studio.mjs

@@ -163,6 +163,31 @@
  *                                         Claude artifact; --open: open it in this computer's browser
  *   homie-studio codex link <id>          a one-time link to the codex on the live site (a private page for the owner)
  *
+ *   homie-studio style init <id> [--prompt "<the person's words>"] [--hands-on] [--budget <usd>]
+ *                                         art direction as decisions (games/<id>/codex/decisions.json): render style,
+ *                                          palette, shape, proportions, materials, light, camera, fonts, effects; the cast,
+ *                                          its routes, library family, scale and budgets; rigs, animation, in-game budgets.
+ *                                          Each starts as an automatic pick with a why; the first asset built on one pins it
+ *   homie-studio style [show] <id> [--phase style]   the decisions (· auto, ~ steered, ● pinned by use, ■ locked)
+ *   homie-studio style set|steer|lock|unlock <id> <decision> …   change one ("warmer"), lock it for the person (--words
+ *                                          "<what they said>"); a locked one changes only with --unlock --reason, and
+ *                                          --confirm after the person saw what goes stale (style blast)
+ *   homie-studio style board <id>         three directions drawn by the engine (free): swatches in codex/board/
+ *   homie-studio style pick <id> <a|b|c> [--mix style.palette=b]   the person's pick (or a mix) from the board
+ *   homie-studio style mood|golden|blast|prompt <id> …   a paid mood image's record, golden images, the blast radius
+ *                                          of a change, the derived style prompt every generation starts from
+ *   homie-studio assets [list] <id>       every asset: route, licence, measurements, spend (games/<id>/assets/manifest.json)
+ *   homie-studio assets find "<words>" [--kind prop] [--family kenney]   the free CC0 starter library (HOMIE_LIBRARY: a copy)
+ *   homie-studio assets add <id> <library item> [--height <m>] | --file <model> --license <kind> [--attribution "…"]
+ *                                          copied in, checked (no external URIs, no oversized files), made phone-sized,
+ *                                          recorded with its licence; RIGHTS.md and credits.json follow
+ *   homie-studio assets redo <id> <asset>   made again from its kept raw file, free (today's budgets and style)
+ *   homie-studio assets optimise <in> --out <file> [--triangles 1500] [--texture 512] [--height <m>]
+ *   homie-studio assets check <id>        phone budgets (triangles, draw calls, picture memory, download), the
+ *                                          glTF-Validator, licences, stale assets, big files in git
+ *   homie-studio assets lineup|review|rights|stale|remove <id> …   the lineup (true scale, silhouettes, palette drift),
+ *                                          a reviewer's score, RIGHTS.md, what a changed decision made stale
+ *
  *   homie-studio statusline               the current build in one line (what Claude Code's status line shows)
  *   homie-studio statusline --install [--project <folder>]
  *                                         turn it on in Claude Code for this studio (.claude/settings.local.json);
@@ -203,11 +228,12 @@ import { installStatusLine, statusLine } from '../lib/statusline.mjs';
 import { restartWithProxy } from '../lib/net.mjs';
 import { demoGames, formatDemo } from '../lib/demo.mjs';
 import { serveMcp } from '../lib/mcp.mjs';
+import { artLines, assetsCommand, styleCommand } from '../lib/art-cli.mjs';
 import { formatHandoff, handoff } from '../lib/handoff.mjs';
 
 const argv = process.argv.slice(2);
 const flags = new Map();
-const BOOL_FLAGS = ['off', 'revoke', 'json', 'yes', 'detach', 'no-install', 'plan', 'stop', 'share', 'apply', 'diff', 'template', 'ci', 'fresh', 'install', 'remove', 'replace', 'artifact', 'open', 'reopen', 'kids', 'remote-ai', 'dry-run', 'verify', 'maps', 'profile'];
+const BOOL_FLAGS = ['off', 'revoke', 'json', 'yes', 'detach', 'no-install', 'plan', 'stop', 'share', 'apply', 'diff', 'template', 'ci', 'fresh', 'install', 'remove', 'replace', 'artifact', 'open', 'reopen', 'kids', 'remote-ai', 'dry-run', 'verify', 'maps', 'profile', 'hands-on', 'automatic', 'unlock', 'confirm', 'no-library', 'no-validate', 'rigged'];
 const positional = [];
 for (let i = 0; i < argv.length; i++) {
   const a = argv[i];
@@ -226,15 +252,27 @@ function print(result) {
   if (result.ok === false && result.command !== 'port check' && !(result.command === 'look' && result.rows)) { process.stdout.write(`homie-studio: ${result.why ?? 'failed'}${result.instead ? `\n${result.instead}` : ''}\n`); return; }
   if (result.ok === false && result.command === 'port check' && !result.rows) { process.stdout.write(`homie-studio: ${result.why ?? 'failed'}\n`); return; }
   const lines = [];
+  if (/^(style|assets)( |$)/.test(String(result.command ?? ''))) { process.stdout.write(`${artLines(result).join('\n')}\n`); return; }
   switch (result.command) {
     case 'new':
       lines.push(`${result.name} is a studio now: ${result.dir}`, '', 'Wrote:', ...result.wrote.map((f) => `  ${f}`), '', `Dependencies: ${result.installed}`, '', 'Next:', ...result.next.map((n) => `  ${n}`), '', result.online);
       break;
     case 'game remix':
       lines.push(`games/${result.id} is a remix of ${result.from} (${result.files.length} files). Its game.json credits the original: "${result.credit}"${result.page ? ` (${result.page})` : ''}, on its landing and in its credits. Make it yours in games/${result.id}/src/, then: npx homie-studio dev`);
+      if (result.assets?.carried) lines.push(`  assets: ${result.assets.fetched.length} carried from the original (checked by SHA-256)${result.assets.placeholders.length ? `, ${result.assets.placeholders.length} grey placeholder(s) where the licence does not let a remix carry them (${result.assets.placeholders.map((p) => p.asset).join(', ')}): see games/${result.id}/assets/RIGHTS.md` : ''}`);
+      if (result.installNeeded) lines.push(`It needs ${result.needsAdded.map((n) => `${n.name} ${n.version}`).join(', ')}, now in the studio's package.json: run npm install first.`);
+      for (const h of result.needsHeld ?? []) lines.push(`It was written against ${h.name} ${h.want}; this studio pins ${h.have}, which stays.`);
+      if (result.needsNotAdded?.length) lines.push(`Its game.json also asks for ${result.needsNotAdded.join(', ')}: not added (a remix adds only what the toolkit's starters use). Read the code before adding any.`);
       break;
     case 'game new':
       lines.push(`games/${result.id} is a new game from the ${result.from} starter. Change it in games/${result.id}/src/, then: npx homie-studio dev`);
+      if (result.installNeeded) lines.push(`It needs ${result.needsAdded.map((n) => `${n.name} ${n.version}`).join(', ')}, now in the studio's package.json: run npm install first.`);
+      for (const h of result.needsHeld ?? []) lines.push(`It was written against ${h.name} ${h.want}; this studio pins ${h.have}, which stays.`);
+      if (result.models) {
+        const m = result.models;
+        lines.push(`Models: ${m.fetched} from the starter library (${m.from}) into games/${result.id}/public/models/, each checked by SHA-256.`);
+        if (m.missing.length) lines.push(`  ${m.missing.length} not here${m.why ? ` (${m.why})` : `: ${m.missing.map((x) => `${x.asset} (${x.why})`).join(', ')}`}. The game draws stand-ins for them; once the library is reachable, homie-studio assets add ${result.id} <item> --as <asset> brings each in (assets/manifest.json names them).`);
+      }
       break;
     case 'dev stop':
       lines.push(result.stopped.length ? `Stopped this studio's dev server (${result.stopped.join(', ')}).` : `Nothing to stop: ${result.why ?? 'no dev server of this studio is running'}.`);
@@ -573,7 +611,11 @@ async function main() {
     if (!positional[2] || !positional[3]) return { ok: false, command: 'perf compare', why: 'usage: homie-studio perf compare <before dir> <after dir> [--goal <metric>] [--min 3]' };
     return perfCompare(positional[2], positional[3], { goal: String(flags.get('goal') ?? DEFAULT_GOAL), min: flags.has('min') ? Number(flags.get('min')) / 100 : 0.03, guards: flags.get('guards') ? String(flags.get('guards')).split(',').map((x) => x.trim()).filter(Boolean) : null, also: flags.get('also') ? String(flags.get('also')).split(',').map((x) => x.trim()).filter(Boolean) : [] });
   }
+  // The starter library and the optimiser work anywhere; the rest of style and assets inside a studio (lib/art-cli.mjs).
+  if (cmd === 'assets' && ['find', 'optimise', 'optimize'].includes(sub)) return assetsCommand(null, sub, positional, flags, { log });
   const root = requireStudio();
+  if (cmd === 'style') return styleCommand(root, sub, positional, flags, { log });
+  if (cmd === 'assets') return assetsCommand(root, sub, positional, flags, { log });
   if (cmd === 'statusline') return installStatusLine(root, { remove: flags.has('remove'), replace: flags.has('replace'), project: flags.get('project') ?? null });
   if (cmd === 'codex') return codexCommand(root, sub);
   if (cmd === 'progress') return progressCommand(root, sub);
@@ -614,6 +656,10 @@ async function main() {
     const game = positional[1] ?? listGames(root)[0]?.id;
     const url = flags.get('url') ?? siteUrl(root);
     if (!url) return { ok: false, command: 'check', why: 'give --url (the local dev address or the live site)' };
+    // A big binary committed under games/ fails the check before any browser starts: it belongs in R2, never in git.
+    const { bigCommittedFiles } = await import('../lib/asset-check.mjs');
+    const big = bigCommittedFiles(root).filter((f) => f.path.startsWith(`games/${game}/`));
+    if (big.length) return { ok: false, command: 'check', why: `committed files over 5 MB under games/${game}: ${big.map((f) => `${f.path} (${(f.bytes / 1024 / 1024).toFixed(1)} MB)`).join(', ')}. Big media goes to the studio's R2 (homie-studio storage add, then media move); raw models stay in art/<slug>/raw/ (git-ignored); a shipped model is made phone-sized with homie-studio assets optimise. Take it out of git (git rm --cached), then check again.` };
     return tracked(root, 'checks', (report) => check({ url, game, shots: flags.get('shots') ? resolve(flags.get('shots')) : null, log, report }), 'check');
   }
   if (cmd === 'look') {

package/lib/art-cli.mjs

@@ -0,0 +1,296 @@
+/**
+ * `homie-studio style …` and `homie-studio assets …` (bin/homie-studio.mjs hands both here): art direction as decisions,
+ * the style board, the asset list with its licences, the checks and the lineup. Every command that changes something
+ * also writes .studio/art/<id>/latest.json, the summary the Studio mod's Art tab and the cards read.
+ *
+ *   style init <id> [--prompt "<the person's words>"] [--hands-on] [--budget <usd>]
+ *   style [show] <id> [--phase style|cast|rigs|animations|game]
+ *   style set <id> <decision> <value> [--by person] [--why "…"] [--unlock --reason "…" [--confirm]]
+ *   style steer <id> <decision> "<words>"            ("warmer", "less saturated", "closer", "golden hour", …)
+ *   style lock <id> <decision>|style --words "<what the person said>"
+ *   style unlock <id> <decision> --reason "<why>"
+ *   style board <id> [--prompt "…"]                   three directions drawn by the engine (free)
+ *   style pick <id> <a|b|c> [--mix style.palette=b,style.camera=c]
+ *   style mood <id> <a|b|c> --image <file> [--usd <n>] [--receipt <file>] [--model <endpoint>]
+ *   style golden <id> add <image> | list
+ *   style blast <id> <decision>                       what changing it makes stale, and what remaking costs
+ *   style prompt <id>                                 the derived style prompt every generation call starts from
+ *
+ *   assets [list] <id>
+ *   assets find "<words>" [--kind prop] [--family kenney] [--limit 12]
+ *   assets add <id> <library item> [--as <id>] [--height <m>] [--card "Items/Berry"]
+ *   assets add <id> --file <model> --license <kind> [--attribution "…"] [--kind prop] [--as <id>] [--height <m>]
+ *                   [--triangles <n>] [--texture <px>] [--route imported|generated] [--steps <steps.json>] [--concept <image>]
+ *   assets optimise <in> --out <file> [--triangles 1500] [--texture 512] [--height <m>]
+ *   assets check <id>       budgets, validator, licences, staleness, scene totals, big files
+ *   assets lineup <id>      the lineup, silhouettes and palette drift (pictures in .studio/art/<id>/)
+ *   assets review <id> --score <1-10> [--outliers a,b] [--note "…"]
+ *   assets rights <id>      RIGHTS.md and credits.json written from the manifest
+ *   assets stale <id>       assets made under an older decision
+ *   assets redo <id> <asset>            made again from its kept raw file (free): today's budgets and render style
+ *   assets remove <id> <asset>
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { licenceProblems, readManifest, removeAsset, rightsMarkdown, syncCredits, writeRights } from './asset-manifest.mjs';
+import { CATALOGUE_IDS, PHASES, blastRadius, decisionRows, derivedPrompt, initDecisions, lockDecision, oneLine, phaseProgress, pickDirection, readDecisions, setDecision, staleAssets, steerDecision, unlockDecision } from './decisions.mjs';
+import { listGames } from './studio.mjs';
+import { checkLines } from './asset-check.mjs';
+
+/** The game a command means: the one named, else the only one. */
+function gameOf(root, id, command) {
+  const games = listGames(root);
+  const planned = id && existsSync(join(root, 'games', id, 'CODEX.md'));
+  if (id && (games.some((g) => g.id === id) || planned)) return id;
+  if (!id && games.length === 1) return games[0].id;
+  throw new Error(`name the game: homie-studio ${command} <id>${games.length ? ` (${games.map((g) => g.id).join(', ')})` : ''}`);
+}
+
+/**
+ * Spend on a game's art, from the receipts (art/receipts.jsonl lines naming the game: every paid call, a redo too),
+ * against the cap the person agreed to (art/<game>-models/budget.json, else the decisions' art budget). A studio
+ * whose older receipts name no game falls back to its assets' recorded steps.
+ */
+export function artSpend(root, id) {
+  const doc = readDecisions(root, id);
+  const items = [];
+  try {
+    for (const line of readFileSync(join(root, 'art', 'receipts.jsonl'), 'utf8').split('\n')) {
+      if (!line.trim()) continue;
+      let r = null;
+      try { r = JSON.parse(line); } catch { continue; }
+      if (r?.game === id && Number(r.cost) > 0 && r.unit === 'usd') items.push({ what: r.what ?? r.artifact ?? r.model, usd: Number(r.cost), receipt: r.requestId ?? null, at: r.at });
+    }
+  } catch { /* no receipts yet */ }
+  if (!items.length) {
+    for (const a of readManifest(root, id).assets) for (const s of a.made?.steps ?? []) if (Number(s.usd) > 0) items.push({ what: `${a.id}: ${s.what}`, usd: Number(s.usd), receipt: s.receipt ?? null });
+    for (const d of doc?.board?.directions ?? []) if (Number(d.mood?.usd) > 0) items.push({ what: `mood image ${d.id}`, usd: Number(d.mood.usd), receipt: d.mood.receipt ?? null });
+  }
+  let cap = doc?.budget?.usd ?? null;
+  try { const b = JSON.parse(readFileSync(join(root, 'art', `${id}-models`, 'budget.json'), 'utf8')); if (Number.isFinite(Number(b.cap))) cap = Number(b.cap); } catch { /* the decisions' budget */ }
+  return { used: +items.reduce((n, x) => n + x.usd, 0).toFixed(3), cap, items };
+}
+
+/** .studio/art/<id>/latest.json: what the mod's Art tab and the cards show, without reading a dozen files. */
+export function writeArtSummary(root, id) {
+  try {
+    const doc = readDecisions(root, id);
+    const manifest = readManifest(root, id);
+    const dir = join(root, '.studio', 'art', id);
+    mkdirSync(dir, { recursive: true });
+    const readJson = (f) => { try { return JSON.parse(readFileSync(join(dir, f), 'utf8')); } catch { return null; } };
+    const check = readJson('check.json');
+    const lineup = readJson('lineup.json');
+    const summary = {
+      v: 1, game: id, at: new Date().toISOString(), path: doc?.path ?? null, line: doc ? oneLine(doc) : null,
+      phases: doc ? PHASES.map((p) => ({ ...p, ...phaseProgress(doc)[p.id] })) : [],
+      decisions: decisionRows(doc).map((p) => ({ phase: p.id, label: p.label, rows: p.rows.map(({ id: d, name, label, state, by, colours }) => ({ id: d, name, label, state, by, colours })) })),
+      cast: manifest.assets.map((a) => ({ id: a.id, kind: a.kind, route: a.route, tier: a.tier ?? null, license: a.license?.kind ?? null, state: a.review?.state ?? 'auto', usd: +(a.made?.steps ?? []).reduce((n, s) => n + (Number(s.usd) || 0), 0).toFixed(3) })),
+      stale: doc ? staleAssets(doc, manifest).map((s) => s.id) : [],
+      licence: licenceProblems(root, id, manifest),
+      spend: artSpend(root, id),
+      check: check ? { ok: check.ok, at: check.at, totals: check.totals, budgets: { drawCalls: check.budgets?.drawCalls, triangles: check.budgets?.triangles, textureMB: check.budgets?.textureMB, firstPlayMB: check.budgets?.firstPlayMB }, failing: check.rows.filter((r) => !r.ok).map((r) => r.id) } : null,
+      lineup: lineup ? { at: lineup.at, flagged: lineup.flagged, images: lineup.images } : null,
+      board: doc?.board ? { chosen: doc.board.chosen, directions: doc.board.directions.map((d) => ({ id: d.id, label: d.label, swatch: d.swatch, mood: d.mood?.path ?? null })) } : null,
+    };
+    writeFileSync(join(dir, 'latest.json'), `${JSON.stringify(summary, null, 2)}\n`);
+    return summary;
+  } catch { return null; }
+}
+
+const list = (v) => String(v ?? '').split(',').map((x) => x.trim()).filter(Boolean);
+
+export async function styleCommand(root, sub, positional, flags, { log = () => {} } = {}) {
+  const known = ['init', 'show', 'set', 'steer', 'lock', 'unlock', 'board', 'pick', 'mood', 'golden', 'blast', 'prompt'];
+  const verb = known.includes(sub) ? sub : 'show';
+  const args = known.includes(sub) ? positional.slice(2) : positional.slice(1);
+  const id = gameOf(root, args[0], `style ${verb}`);
+  const manifest = () => readManifest(root, id);
+  let r;
+  if (verb === 'init') r = initDecisions(root, id, { prompt: String(flags.get('prompt') ?? ''), path: flags.has('hands-on') ? 'hands-on' : flags.has('automatic') ? 'automatic' : null, budget: flags.has('budget') ? Number(flags.get('budget')) : null });
+  else if (verb === 'show') {
+    const doc = readDecisions(root, id);
+    if (!doc) return { ok: false, command: 'style', why: `games/${id} has no decisions yet: homie-studio style init ${id} --prompt "<the person's words>"` };
+    const phase = flags.get('phase') ?? null;
+    r = { ok: true, command: 'style', id, line: oneLine(doc), path: doc.path, budget: doc.budget, phases: decisionRows(doc).filter((p) => !phase || p.id === phase), progress: phaseProgress(doc), prompt: doc.derived?.prompt ?? null, board: doc.board ? { chosen: doc.board.chosen, directions: doc.board.directions.map((d) => ({ id: d.id, label: d.label, swatch: d.swatch, mood: d.mood?.path ?? null })) } : null, golden: doc.golden ?? [], stale: staleAssets(doc, manifest()) };
+  } else if (verb === 'set') {
+    if (!args[1] || args[2] === undefined) return { ok: false, command: 'style set', why: `usage: homie-studio style set <id> <decision> <value> (decisions: ${CATALOGUE_IDS.slice(0, 10).join(', ')}, …)` };
+    r = setDecision(root, id, args[1], args.slice(2).join(' '), { by: flags.get('by') === 'person' ? 'person' : 'ai', why: flags.get('why') ?? null, words: flags.get('words') ?? null, unlock: flags.has('unlock'), reason: flags.get('reason') ?? null, confirm: flags.has('confirm'), manifest: manifest() });
+  } else if (verb === 'steer') r = steerDecision(root, id, args[1], args.slice(2).join(' ') || String(flags.get('words') ?? ''), { manifest: manifest() });
+  else if (verb === 'lock') r = lockDecision(root, id, args[1] ?? 'style', { by: 'person', words: flags.get('words') ?? null });
+  else if (verb === 'unlock') r = unlockDecision(root, id, args[1], { reason: flags.get('reason') ?? null, by: 'person' });
+  else if (verb === 'board') { const { styleBoard } = await import('./style-board.mjs'); r = await styleBoard(root, id, { prompt: String(flags.get('prompt') ?? ''), log, library: !flags.has('no-library') }); }
+  else if (verb === 'pick') {
+    const mixes = Object.fromEntries(list(flags.get('mix')).map((x) => x.split('=')).filter(([k, v]) => k && v));
+    r = pickDirection(root, id, args[1] && !args[1].includes('=') ? args[1] : null, { mixes, manifest: manifest() });
+  } else if (verb === 'mood') { const { recordMood } = await import('./style-board.mjs'); r = await recordMood(root, id, args[1], resolve(String(flags.get('image') ?? '')), { usd: flags.get('usd') ?? null, receipt: flags.get('receipt') ?? null, model: flags.get('model') ?? null }); }
+  else if (verb === 'golden') {
+    if (args[1] === 'add') { const { addGolden } = await import('./style-board.mjs'); r = await addGolden(root, id, resolve(String(args[2] ?? flags.get('image') ?? '')), { from: flags.get('from') ?? null }); }
+    else r = { ok: true, command: 'style golden', id, golden: readDecisions(root, id)?.golden ?? [] };
+  } else if (verb === 'blast') {
+    const doc = readDecisions(root, id);
+    if (!doc) return { ok: false, command: 'style blast', why: `games/${id} has no decisions yet` };
+    if (!doc.decisions[args[1]]) return { ok: false, command: 'style blast', why: `no decision "${args[1] ?? ''}"` };
+    r = { ok: true, command: 'style blast', id, blast: blastRadius(doc, args[1], manifest()) };
+  } else if (verb === 'prompt') {
+    const doc = readDecisions(root, id);
+    if (!doc) return { ok: false, command: 'style prompt', why: `games/${id} has no decisions yet` };
+    r = { ok: true, command: 'style prompt', id, prompt: derivedPrompt(doc), golden: doc.golden ?? [] };
+  }
+  if (r?.ok !== false) writeArtSummary(root, id);
+  return r;
+}
+
+export async function assetsCommand(root, sub, positional, flags, { log = () => {} } = {}) {
+  const known = ['list', 'find', 'add', 'redo', 'optimise', 'optimize', 'check', 'lineup', 'review', 'rights', 'stale', 'remove'];
+  const verb = known.includes(sub) ? (sub === 'optimize' ? 'optimise' : sub) : 'list';
+  const args = known.includes(sub) ? positional.slice(2) : positional.slice(1);
+  if (verb === 'find') {
+    const { loadIndex, searchLibrary, libraryBase } = await import('./library.mjs');
+    const { index, lib } = await loadIndex({ lib: libraryBase(flags.get('library') ?? undefined) });
+    const hits = searchLibrary(index, args.join(' '), { kind: flags.get('kind') ?? null, family: flags.get('family') ?? null, limit: Number(flags.get('limit') ?? 12) });
+    return { ok: true, command: 'assets find', query: args.join(' '), library: lib.base, version: index.version, total: index.items.length, items: hits.map(({ item, score, why }) => ({ id: item.id, name: item.name, kind: item.kind, family: item.family, pack: item.pack, tris: item.tris, kb: Math.round((item.files?.[0]?.bytes ?? 0) / 1024), heightM: item.heightM, suggestM: item.suggestM ?? null, rigged: Boolean(item.rigged), clips: item.clips ?? [], thumb: item.thumb, license: 'CC0 1.0', score: +score.toFixed(2), why })) };
+  }
+  if (verb === 'optimise') {
+    const { optimiseModel } = await import('./optimise.mjs');
+    if (!args[0] || !flags.get('out')) return { ok: false, command: 'assets optimise', why: 'usage: homie-studio assets optimise <model.glb> --out <file.glb> [--triangles 1500] [--texture 512] [--height <m>]' };
+    const r = await optimiseModel(resolve(args[0]), { out: resolve(String(flags.get('out'))), triangles: Number(flags.get('triangles') ?? 1500), texture: Number(flags.get('texture') ?? 512), height: flags.has('height') ? Number(flags.get('height')) : null, rigged: flags.has('rigged'), log });
+    const { glb, ...rest } = r;
+    return { ...rest, command: 'assets optimise' };
+  }
+  const id = gameOf(root, args[0], `assets ${verb}`);
+  let r;
+  if (verb === 'list') {
+    const m = readManifest(root, id);
+    const doc = readDecisions(root, id);
+    r = { ok: true, command: 'assets', id, assets: m.assets.map((a) => ({ id: a.id, kind: a.kind, route: a.route, tier: a.tier ?? null, card: a.card ?? null, license: a.license?.kind ?? null, remix: a.license?.remix ?? null, file: (a.files ?? []).find((f) => f.role === 'model')?.path ?? null, tris: a.measured?.tris ?? null, kb: a.measured?.glbKB ?? null, usd: +(a.made?.steps ?? []).reduce((n, s) => n + (Number(s.usd) || 0), 0).toFixed(3) })), stale: doc ? staleAssets(doc, m).map((s) => s.id) : [], spend: artSpend(root, id) };
+  } else if (verb === 'add') {
+    if (flags.get('file')) {
+      const { importModel } = await import('./asset-import.mjs');
+      let steps = [];
+      if (flags.get('steps')) steps = JSON.parse(readFileSync(resolve(String(flags.get('steps'))), 'utf8'));
+      r = await importModel(root, id, String(flags.get('file')), { as: flags.get('as') ?? args[1] ?? null, kind: flags.get('kind') ?? 'prop', tier: flags.get('tier') ?? null, card: flags.get('card') ?? null, height: flags.get('height') ?? null, triangles: flags.get('triangles') ?? null, texture: flags.get('texture') ?? null, license: flags.get('license') ?? null, attribution: flags.get('attribution') ?? null, notes: flags.get('notes') ?? null, owner: flags.get('owner') ?? null, route: flags.get('route') ?? 'imported', steps, concept: flags.get('concept') ?? null, slug: flags.get('slug') ?? null, rigged: flags.has('rigged') });
+    } else {
+      if (!args[1]) return { ok: false, command: 'assets add', why: 'usage: homie-studio assets add <game> <library item> (assets find "<words>" lists them), or --file <model> --license <kind>' };
+      const { addFromLibrary, libraryBase } = await import('./library.mjs');
+      r = await addFromLibrary(root, id, args[1], { as: flags.get('as') ?? null, height: flags.get('height') ?? null, card: flags.get('card') ?? null, lib: libraryBase(flags.get('library') ?? undefined) });
+    }
+  } else if (verb === 'redo') {
+    if (!args[1]) return { ok: false, command: 'assets redo', why: 'usage: homie-studio assets redo <game> <asset> (made again from its kept raw file, free)' };
+    const { redoModel } = await import('./asset-import.mjs');
+    r = await redoModel(root, id, args[1]);
+  } else if (verb === 'check') { const { assetsCheck } = await import('./asset-check.mjs'); r = await assetsCheck(root, id, { validate: !flags.has('no-validate') }); }
+  else if (verb === 'lineup') { const { assetsLineup } = await import('./style-board.mjs'); r = await assetsLineup(root, id, { log }); }
+  else if (verb === 'review') { const { recordReview } = await import('./style-board.mjs'); r = recordReview(root, id, { score: flags.get('score'), outliers: list(flags.get('outliers')), note: flags.get('note') ?? null }); }
+  else if (verb === 'rights') { const m = readManifest(root, id); const file = writeRights(root, id, m); syncCredits(root, id, m); r = { ok: true, command: 'assets rights', id, file, text: rightsMarkdown(root, id, m), licence: licenceProblems(root, id, m) }; }
+  else if (verb === 'stale') { const doc = readDecisions(root, id); r = { ok: true, command: 'assets stale', id, stale: doc ? staleAssets(doc, readManifest(root, id)) : [] }; }
+  else if (verb === 'remove') { const x = removeAsset(root, id, args[1]); r = { ok: x.removed, command: 'assets remove', id, asset: args[1], deleted: x.deleted, kept: x.kept, ...(x.removed ? {} : { why: `no asset "${args[1]}" in games/${id}/assets/manifest.json` }) }; }
+  if (r?.ok !== false || verb === 'check') writeArtSummary(root, id);
+  return r;
+}
+
+/* ------------------------------------------------------------------ what a person reads */
+
+const MARK = { auto: '·', steered: '~', pinned: '●', locked: '■' };
+
+export function artLines(r) {
+  const L = [];
+  switch (r.command) {
+    case 'style init':
+      L.push(`${r.summary}.`, `  ${r.picked.length} decision${r.picked.length === 1 ? '' : 's'} picked automatically (a ${r.genre} game)${r.kept.length ? `; ${r.kept.length} kept as the person set them` : ''}. ${r.file}`, '  Open the codex to change anything; steer, lock or the style board give the person control.');
+      break;
+    case 'style': {
+      L.push(`${r.id}: ${r.line}`, `  path: ${r.path}${r.budget ? `, art budget US$${r.budget.usd}` : ', free routes only (no art budget)'}`);
+      for (const p of r.phases) {
+        L.push(`  ${p.label}:`);
+        for (const x of p.rows) L.push(`    ${MARK[x.state] ?? ' '} ${x.id.padEnd(18)} ${x.label}${x.state !== 'auto' ? `  [${x.state}${x.by === 'person' ? ', the person' : x.by === 'use' ? ', by use' : ''}]` : ''}`);
+      }
+      L.push('  · auto  ~ steered  ● pinned by use  ■ locked');
+      if (r.stale?.length) L.push(`  stale: ${r.stale.map((s) => s.id).join(', ')}`);
+      break;
+    }
+    case 'style set':
+      if (r.pending) { L.push(`Not changed yet: ${r.decision} is locked. If it changes:`, ...blastLines(r.blast), r.why); break; }
+      L.push(`${r.decision}: ${r.record.label} (${r.record.state}, rev ${r.record.rev})`, ...(r.blast ? blastLines(r.blast) : []), ...(r.stale?.length ? [`  stale now: ${r.stale.join(', ')}`] : []));
+      break;
+    case 'style steer':
+      L.push(`${r.decision}: ${r.record.label} (steered: "${r.recorded}")`, ...(r.note ? [`  ${r.note}`] : []), ...(r.stale?.length ? [`  stale now: ${r.stale.join(', ')}`] : []));
+      break;
+    case 'style lock':
+      L.push(r.locked.length ? `Locked: ${r.locked.join(', ')}` : 'Nothing new to lock.', ...(r.already.length ? [`  already locked: ${r.already.join(', ')}`] : []));
+      break;
+    case 'style unlock':
+      L.push(r.already ? `${r.decision} was not locked.` : `Unlocked ${r.decision} (now steered).`);
+      break;
+    case 'style board':
+      L.push(`The style board for ${r.title} (drawn on ${r.renderer ?? 'this computer'}, free):`);
+      for (const d of r.directions) L.push(`  ${d.id.toUpperCase()}: ${d.label}  [${d.family}]`, `     swatch: games/${r.id}/${d.swatch}${d.mood ? `  mood (target): games/${r.id}/${d.mood.path}` : ''}`);
+      L.push('  Pick, Mix, Steer or Lock: homie-studio style pick <id> <a|b|c> [--mix style.palette=b]; style lock <id> style --words "…"');
+      break;
+    case 'style pick':
+      L.push(r.changed.length ? `Picked ${r.chosen ? `direction ${r.chosen.toUpperCase()}` : 'a mix'}: ${r.changed.join(', ')}` : 'Nothing changed (the board\'s values are the game\'s already).', ...(r.refused.length ? [`  left as locked: ${r.refused.join(', ')}`] : []), ...(r.stale?.length ? [`  stale now: ${r.stale.join(', ')}`] : []));
+      break;
+    case 'style mood':
+      L.push(`Mood image (a target, not what the game draws) for direction ${r.direction.toUpperCase()}: ${r.mood.path}${r.mood.usd ? ` (US$${r.mood.usd})` : ''}`);
+      break;
+    case 'style golden':
+      L.push(`${r.golden.length} golden image${r.golden.length === 1 ? '' : 's'}:`, ...r.golden.map((g) => `  ${g.path} (from ${g.from})`));
+      break;
+    case 'style blast':
+      L.push(...blastLines(r.blast));
+      break;
+    case 'style prompt':
+      L.push(`Derived style prompt (rev ${r.prompt.rev}):`, `  ${r.prompt.text}`, ...(r.golden.length ? [`Golden images (references): ${r.golden.map((g) => g.path).join(', ')}`] : []));
+      break;
+    case 'assets':
+      L.push(`${r.id}: ${r.assets.length} asset${r.assets.length === 1 ? '' : 's'}${r.spend.used ? `, US$${r.spend.used} spent${r.spend.cap !== null ? ` of US$${r.spend.cap}` : ''}` : ', US$0 spent'}`);
+      for (const a of r.assets) L.push(`  ${a.id.padEnd(20)} ${a.kind.padEnd(9)} ${a.route.padEnd(10)} ${String(a.license ?? 'NO LICENCE').padEnd(10)} ${a.tris ?? '?'} tris, ${a.kb ?? '?'} KB${a.usd ? `, US$${a.usd}` : ''}${r.stale.includes(a.id) ? '  STALE' : ''}`);
+      break;
+    case 'assets find':
+      L.push(`${r.items.length} of ${r.total} library items for "${r.query}" (CC0, free; ${r.library}):`);
+      for (const i of r.items) L.push(`  ${i.id.padEnd(46)} ${i.kind.padEnd(9)} ${String(i.tris).padStart(5)} tris ${String(i.kb).padStart(4)} KB${i.rigged ? `  rigged${i.clips.length ? `, ${i.clips.length} clips` : ''}` : ''}`);
+      if (r.items.length) L.push(`  Add one: homie-studio assets add <game> ${r.items[0].id} [--height <m>]`);
+      break;
+    case 'assets add':
+      L.push(`games/${r.game}: ${r.asset} added (${r.item ? `from the library: ${r.item}` : r.route}; licence ${r.license}).`, ...(r.after ? [`  ${r.before.tris} -> ${r.after.tris} triangles, ${r.before.kb} -> ${r.after.kb} KB, ${r.after.heightM} m tall; raw kept in ${r.raw} (git-ignored)`] : []), ...(r.pinned?.length ? [`  pinned by use: ${r.pinned.join(', ')}`] : []), ...(r.warnings ?? []).map((w) => `  note: ${w}`));
+      break;
+    case 'assets redo':
+      L.push(`games/${r.game}: ${r.asset} made again from its raw file (free): ${r.before.tris} -> ${r.after.tris} triangles, ${r.after.kb} KB, ${r.after.heightM} m (${r.ops.join(', ')})`, ...(r.warnings ?? []).map((w) => `  note: ${w}`));
+      break;
+    case 'assets optimise':
+      L.push(`${r.out}: ${r.before.triangles} -> ${r.after.triangles} triangles, ${Math.round(r.rawBytes / 1024)} -> ${Math.round(r.bytes / 1024)} KB (${r.ops.join(', ')})`, ...r.warnings.map((w) => `  note: ${w}`));
+      break;
+    case 'assets lineup':
+      if (r.ok === false) { L.push(r.why); break; }
+      L.push(`Lineup of ${r.rows.length} asset${r.rows.length === 1 ? '' : 's'} (${r.flagged} flagged), pictures: ${r.images.front}, ${r.images.quarter}, ${r.images.silhouettes}`);
+      for (const x of r.rows) L.push(`  ${x.flags.length ? 'FLAG' : 'ok  '} ${x.id}${x.size ? ` (${x.size[1]} m)` : ''}${x.drift ? (x.drift.repaint ? ', repainted from style.json in the game' : `, palette distance ${x.drift.mean}`) : ''}${x.flags.length ? `: ${x.flags.join('; ')}` : ''}`);
+      L.push('  Next: a fresh reviewer scores "one game?" from the board, golden images and this lineup (assets review <id> --score <n>).');
+      break;
+    case 'assets review':
+      L.push(`Review: ${r.review.score}/10, ${r.review.verdict}${r.review.outliers.length ? `; needs review: ${r.review.outliers.join(', ')}` : ''}`);
+      break;
+    case 'assets rights':
+      L.push(`Wrote ${r.file} (and credits.json).`, ...r.licence.map((l) => `  ${l.level === 'refuse' ? 'FIX ' : 'note'} ${l.asset}: ${l.problem}`));
+      break;
+    case 'assets stale':
+      L.push(r.stale.length ? `Stale (made under an older decision; nothing is remade by itself):` : 'Nothing is stale.', ...r.stale.map((s) => `  ${s.id}: ${s.decisions.map((d) => `${d.id} rev ${d.was} -> ${d.now}`).join(', ')}`));
+      break;
+    case 'assets remove':
+      L.push(r.ok ? `Removed ${r.asset} from the manifest${r.deleted.length ? `, and its shipped copy (${r.deleted.join(', ')})` : ''}.${r.kept.length ? ` Kept ${r.kept.join(', ')}: changed since it was recorded, so delete it yourself if it is unused.` : ''} A raw file in art/ stays.` : r.why);
+      break;
+    case 'assets check':
+      L.push(...checkLines(r));
+      break;
+    default:
+      L.push(JSON.stringify(r, null, 2));
+  }
+  return L;
+}
+
+export function blastLines(b) {
+  const L = [`Changing the ${b.name} (${b.from ?? '?'}${b.to ? ` -> ${b.to}` : ''}): ${b.assets.length} asset${b.assets.length === 1 ? '' : 's'} would go stale${b.assets.length ? `; remaking the ones with no free fix costs about US$${b.totals.usd.toFixed(2)}` : ''}.`];
+  for (const a of b.assets) L.push(`  ${a.id} (${a.route}${a.card ? `, ${a.card}` : ''}): ${a.free ? `free: ${a.free}` : a.remake.usd ? `US$${a.remake.usd.toFixed(2)} (${a.remake.how})` : a.remake.how}`);
+  if (b.decisions.length) L.push(`  also worth a look: ${b.decisions.slice(0, 8).join(', ')}`);
+  L.push(`  ${b.note}`);
+  return L;
+}