@homie-rocks/studio 0.20.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

@@ -94,8 +94,9 @@
  *   homie-studio office invite <game> [--label "<who>"] [--uses 1|<n>|any] [--count 1] [--days <n>] [--server <id>]
  *   homie-studio office launch <game> private|invite|public [--remixable on|off] [--max <n>|game]
  *   homie-studio office kick <game> <room> <seat number | name> [--minutes 10]
+ *   homie-studio office mute <game> <room> <seat number | name> [--minutes 10] [--off]
  *   homie-studio office close <game> <room> [--minutes 10] [--reopen]
- *                                         (kick, close and launch are ASKED for: the owner confirms each with one
+ *                                         (kick, mute, close and launch are ASKED for: the owner confirms each with one
  *                                          tap in their own browser, from the link this prints)
  *   homie-studio office revoke            (every office key, play ticket and pending ask ends)
  *
@@ -162,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);
@@ -192,7 +218,7 @@ import { listGames, newGame, readStudio, remixGame, requireStudio, siteUrl, star
 import { STUDIO_VERSION } from '../lib/version.mjs';
 import { statsKey, statsLink, statsRevoke, statsShare, statsShow } from '../lib/stats.mjs';
 import { playersOwner, playersShow } from '../lib/players.mjs';
-import { officeAnnounce, officeClose, officeInvite, officeKey, officeKick, officeLaunch, officeLines, officeLink, officeRevoke, officeShow } from '../lib/office.mjs';
+import { officeAnnounce, officeClose, officeInvite, officeKey, officeKick, officeLaunch, officeLines, officeLink, officeMute, officeRevoke, officeShow } from '../lib/office.mjs';
 import { agentsBrain, agentsBrainKey, agentsPass, agentsPasses, agentsRevoke, serversClose, serversLevel, serversLines, serversList, serversMember, serversNew, serversSet } from '../lib/servers.mjs';
 import { AgentSeat } from '../lib/agent-seat.mjs';
 import { Feed, currentFeed, currentId, flushProgress, publicFeed, readFeed, recordChange, startProgress } from '../lib/progress.mjs';
@@ -202,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 = ['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];
@@ -225,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'}.`);
@@ -411,6 +450,7 @@ function print(result) {
     case 'agents brain':
     case 'office launch':
     case 'office kick':
+    case 'office mute':
     case 'office close':
       lines.push(result.asked ? `Asked: ${result.what}` : result.message, ...(result.asked ? [`Owner's one-tap link (until the ask ends, 15 min): ${result.link}`, result.use] : []));
       break;
@@ -571,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);
@@ -612,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') {
@@ -654,6 +702,7 @@ async function main() {
     if (sub === 'invite') return officeInvite(root, positional[2], { url, label: flags.get('label'), uses: flags.get('uses'), count: flags.get('count'), days: flags.get('days'), server: flags.get('server') });
     if (sub === 'launch') return officeLaunch(root, positional[2], positional[3], { url, remixable: flags.get('remixable'), max: flags.get('max') });
     if (sub === 'kick') return officeKick(root, positional[2], positional[3], positional.slice(4).join(' ') || undefined, { url, minutes: flags.get('minutes') });
+    if (sub === 'mute') return officeMute(root, positional[2], positional[3], positional.slice(4).join(' ') || undefined, { url, minutes: flags.get('minutes'), off: flags.has('off') });
     if (sub === 'close') return officeClose(root, positional[2], positional[3], { url, minutes: flags.get('minutes'), reopen: flags.has('reopen') });
     if (sub === 'revoke') return officeRevoke(root, { url });
   }