@homie-rocks/studio 0.14.2 → 0.14.3

package/README.md

@@ -100,8 +100,8 @@ site. A game made with Homie's arcade controls that knocks for a Homie box (`/__
 A studio pins one version, so nothing changes until it asks. To take a newer one:
 
 ```sh
-npx -y @homie-rocks/studio@0.14.2 upgrade          # the plan; changes nothing
-npx -y @homie-rocks/studio@0.14.2 upgrade --apply  # after the person agrees
+npx -y @homie-rocks/studio@0.14.3 upgrade          # the plan; changes nothing
+npx -y @homie-rocks/studio@0.14.3 upgrade --apply  # after the person agrees
 npm install && npm run build
 ```
 
@@ -232,7 +232,7 @@ device; the owner's own passkey account (`homie-studio players owner`) counts as
 ## Setup status
 
 ```sh
-npx -y @homie-rocks/studio@0.14.2 setup status --connector yes   # before a studio exists
+npx -y @homie-rocks/studio@0.14.3 setup status --connector yes   # before a studio exists
 npx homie-studio setup status                                    # in a studio (also: homie-studio doctor)
 ```
 

package/lib/files.mjs

@@ -7,9 +7,11 @@
  */
 import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, realpathSync, statSync, writeFileSync } from 'node:fs';
 import { dirname, extname, join, relative, resolve, sep } from 'node:path';
+import { PICTURE_MAX, PICTURE_TYPES, pictureFor } from './pictures.mjs';
 
-export const FILE_LIMITS = Object.freeze({ write: 2 * 1024 * 1024, read: 400 * 1024, image: 1536 * 1024, lines: 2000, list: 600, matches: 200 });
-const IMAGES = { '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.webp': 'image/webp', '.gif': 'image/gif' };
+// A picture is at most PICTURE_MAX raw in an answer (lib/pictures.mjs): a bigger one goes as a smaller JPEG copy.
+export const FILE_LIMITS = Object.freeze({ write: 2 * 1024 * 1024, read: 400 * 1024, image: PICTURE_MAX, lines: 2000, list: 600, matches: 200 });
+const IMAGES = PICTURE_TYPES;
 const SKIP_DIRS = new Set(['node_modules', '.git', '.wrangler', '.studio', 'dist']);
 
 const inside = (base, p) => p === base || p.startsWith(base.endsWith(sep) ? base : `${base}${sep}`);
@@ -79,8 +81,9 @@ export function readStudioFile(root, path, { offset = 1, limit = FILE_LIMITS.lin
   if (st.isDirectory()) throw new Error(`${rel} is a folder (file_list lists it)`);
   const mime = IMAGES[extname(abs).toLowerCase()];
   if (mime) {
-    if (st.size > FILE_LIMITS.image) throw new Error(`${rel} is ${Math.round(st.size / 1024)} KB, over the ${FILE_LIMITS.image / 1024} KB a picture may be here`);
-    return { rel, image: { mimeType: mime, data: readFileSync(abs).toString('base64') }, bytes: st.size };
+    // Small enough for one answer (the Claude desktop app refuses one over 1 MB): a big picture goes as a smaller copy.
+    const pic = pictureFor(abs, { label: rel });
+    return { rel, image: { mimeType: pic.mimeType, data: pic.data }, bytes: pic.bytes, shrunk: pic.shrunk, from: pic.from ?? st.size };
   }
   if (st.size > FILE_LIMITS.read * 8) throw new Error(`${rel} is ${Math.round(st.size / 1024)} KB: too big to read here`);
   const buf = readFileSync(abs);

package/lib/mcp-tools.mjs

@@ -13,7 +13,7 @@
  * file tools never leave it (lib/files.mjs).
  */
 import { spawnSync } from 'node:child_process';
-import { existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, rmSync, statSync } from 'node:fs';
+import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { basename, dirname, extname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { renderCodex, newCodex } from './codex.mjs';
@@ -399,6 +399,80 @@ async function startDev(ctx, root, port) {
   return { url: `http://127.0.0.1:${at}`, job, slow: true };
 }
 
+/* ------------------------------------------------------------------ an earlier attempt, folded in */
+
+/** Where a person keeps projects, looked at two levels deep for an earlier folder of a studio's name. */
+const PROJECT_ROOTS = ['dev', 'Developer', 'code', 'Code', 'src', 'projects', 'Projects', 'repos', 'git', 'work', 'Documents', 'Desktop'];
+const TEXT_NOTES = new Set(['.md', '.markdown', '.txt', '.json', '.yaml', '.yml', '.toml', '.csv', '.html', '.css', '.js', '.mjs', '.ts', '.tsx']);
+const SKIP = new Set(['node_modules', '.git', 'Library', 'dist', '.studio', '.wrangler']);
+
+/** Folders named like the studio that are not studios: [{ path, files }] (at most 3). */
+export function earlierFolders(ctx, names, own, home = homedir()) {
+  const want = new Set(names.filter(Boolean).map((n) => String(n).toLowerCase()));
+  const roots = [ctx.studiosDir, home, ...PROJECT_ROOTS.map((r) => join(home, r))].filter((r) => r && existsSync(r));
+  const found = new Map();
+  const look = (dir, depth) => {
+    let entries = [];
+    try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const e of entries) {
+      if (found.size >= 3) return;
+      if (!e.isDirectory() || e.name.startsWith('.') || SKIP.has(e.name)) continue;
+      const p = join(dir, e.name);
+      if (want.has(e.name.toLowerCase()) && realOr(p) !== realOr(own) && !existsSync(join(p, 'studio.json'))) {
+        let files = [];
+        try { files = readdirSync(p).filter((f) => !f.startsWith('.')).slice(0, 12); } catch { files = []; }
+        found.set(realOr(p), { path: realOr(p), files });
+      } else if (depth > 1 && entries.length < 400) look(p, depth - 1);
+    }
+  };
+  for (const r of [...new Set(roots.map(realOr))]) look(r, r === realOr(home) ? 1 : 2);
+  return [...found.values()];
+}
+
+/** studio_fold: the earlier folder's notes into notes/earlier/, or (remove) the folder into the Trash. */
+async function foldEarlier(ctx, root, a) {
+  const from = realOr(expandHome(a.from) ?? '');
+  const known = ctx.note(root).earlier ?? earlierFolders(ctx, [readStudio(root).name, readStudio(root).slug, basename(root)], root).map((e) => e.path);
+  if (!known.includes(from)) return fail(`${a.from} is not an earlier folder found for this studio (${known.join(', ') || 'none was found'}); nothing was touched`);
+  if (!existsSync(from)) return fail(`${from} is not there any more`);
+  if (a.remove === true) {
+    const trash = join(homedir(), '.Trash');
+    if (process.platform !== 'darwin' || !existsSync(trash)) return fail(`Moving a folder to the Trash works on a Mac only: the person can remove ${from} themselves.`);
+    const to = join(trash, `${basename(from)} ${new Date().toISOString().slice(0, 19).replace(/:/g, '.')}`);
+    try { renameSync(from, to); } catch (error) { return fail(`${from} could not be moved to the Trash (${error.code ?? error.message}): the person can remove it themselves`); }
+    ctx.note(root).earlier = known.filter((p) => p !== from);
+    return ok(`Moved ${from} to the Trash (as "${basename(to)}"); the person can put it back from there.`);
+  }
+  const dest = join(root, 'notes', 'earlier', basename(from));
+  const copied = [];
+  let total = 0;
+  const walk = (dir, rel) => {
+    let entries = [];
+    try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const e of entries) {
+      if (copied.length >= 60 || total > 2 * 1024 * 1024) return;
+      if (e.name.startsWith('.') || SKIP.has(e.name)) continue;
+      const p = join(dir, e.name);
+      const r = rel ? `${rel}/${e.name}` : e.name;
+      if (e.isDirectory()) { walk(p, r); continue; }
+      if (!e.isFile() || !TEXT_NOTES.has(extname(e.name).toLowerCase())) continue;
+      const size = statSync(p).size;
+      if (size > 200 * 1024) continue;
+      mkdirSync(dirname(join(dest, r)), { recursive: true });
+      copyFileSync(p, join(dest, r));
+      copied.push(r); total += size;
+    }
+  };
+  walk(from, '');
+  let shown = '';
+  for (const r of copied.filter((f) => /\.(md|markdown|txt)$/i.test(f))) {
+    if (shown.length > 30_000) break;
+    shown += `\n--- ${r}\n${readFileSync(join(dest, r), 'utf8').split('\n').slice(0, 80).join('\n')}\n`;
+  }
+  ctx.note(root).changed = true;
+  return ok(`Copied ${copied.length} note file${copied.length === 1 ? '' : 's'} from ${from} into notes/earlier/${basename(from)}/ (the old folder is unchanged). Fold its premise into the plan with the person (the game's CODEX.md), then ask whether to remove the old folder (studio_fold with remove: true moves it to the Trash).${shown ? `\n${shown}` : ''}`, { kind: 'fold', from, to: `notes/earlier/${basename(from)}`, files: copied });
+}
+
 /* ------------------------------------------------------------------ a studio from GitHub */
 
 /** owner/name of a checkout's origin remote, lowercased, or null. */
@@ -517,19 +591,34 @@ export function toolDefs(ctx, avail = {}) {
         // Compared on real paths (a temporary or linked folder may have two names).
         const dir = join(realOr(dirname(asked)), basename(asked));
         if (!inside(base, dir) || dir === base) return fail(`a studio goes in its own folder inside ${ctx.studiosDir}`);
+        // An earlier attempt for this name (a folder that is not a studio: notes, a plan, a charter), here or in the
+        // usual project folders: the person is offered to fold its premise in (studio_fold), never surprised by it.
+        const earlier = earlierFolders(ctx, [name, slugify(name), basename(dir)], dir);
+        let at = dir;
+        if (existsSync(at) && readdirSync(at).some((f) => !['.DS_Store', '.git'].includes(f)) && !existsSync(join(at, 'studio.json'))) at = `${dir}-studio`;
         let made;
-        try { made = newStudio(dir, { name, install: false, ...(ctx.directory ? { homie: ctx.directory } : {}) }); } catch (error) { return fail(error.message); }
+        try { made = newStudio(at, { name, install: false, ...(ctx.directory ? { homie: ctx.directory } : {}) }); } catch (error) { return fail(error.message); }
         ctx.current = made.dir;
+        ctx.note(made.dir).earlier = earlier.map((e) => e.path);
         let install = null;
         if (ctx.install) {
           try { install = installJob(made.dir); } catch (error) { return fail(`${name} is made at ${made.dir}, but ${error.message}`); }
           await waitJob(install, Math.min(ctx.waitMs, 35_000));
         }
         const r = await setupCard(ctx, made.dir, { install, made: { dir: made.dir, wrote: made.wrote } });
-        r.content[0].text = `Made ${name} at ${made.dir} (no game yet: its home page says "First game coming soon").\nWrote: ${made.wrote.join(', ')}\n${!install ? '' : install.endedAt ? (install.code === 0 ? 'Its toolkit is installed.' : `npm install failed: ${whyOf(install)}`) : `Its toolkit is installing (job ${install.id}).`}\n\n${r.content[0].text}`;
+        const fold = earlier.length ? `\n\nAn earlier folder for this name is on this computer, and it is not a studio: ${earlier.map((e) => `${e.path} (${e.files.join(', ') || 'empty'})`).join('; ')}. ASK the person: fold its premise into ${name}? With their yes, studio_fold { "from": "<that folder>" } copies its notes into the studio (notes/earlier/) and shows them to you, so the plan can use them. Then, only with another yes, studio_fold { "from": "<that folder>", "remove": true } moves the old folder to the Trash.` : '';
+        r.content[0].text = `Made ${name} at ${made.dir} (no game yet: its home page says "First game coming soon").\nWrote: ${made.wrote.join(', ')}\n${!install ? '' : install.endedAt ? (install.code === 0 ? 'Its toolkit is installed.' : `npm install failed: ${whyOf(install)}`) : `Its toolkit is installing (job ${install.id}).`}${fold}\n\n${r.content[0].text}`;
+        if (r.structuredContent) r.structuredContent.earlier = earlier;
         return r;
       },
     },
+    {
+      name: 'studio_fold', title: 'Fold an earlier folder into the studio',
+      description: 'An earlier folder for this studio\'s name that is not a studio (one studio_scaffold found and named): copy its notes into the studio (notes/earlier/<folder>/, text files only) and read them, so its premise goes into the plan; or, with remove: true, move the old folder to the Trash. Only with the person\'s yes for each; it never touches any other folder.',
+      inputSchema: { type: 'object', properties: { from: str('The earlier folder studio_scaffold named'), remove: { type: 'boolean', description: 'Move the earlier folder to the Trash (only with the person\'s yes)' }, ...STUDIO_ARG }, required: ['from'] },
+      annotations: { title: 'Fold an earlier folder in', readOnlyHint: false, destructiveHint: true, openWorldHint: false },
+      run: async (a) => foldEarlier(ctx, ctx.root(a.studio), a),
+    },
     {
       name: 'studio_install', title: 'Install the studio\'s dependencies',
       description: 'npm install in the studio: its pinned toolkit and Wrangler, and anything its package.json gained (after an upgrade, a new pin, or a library a game needs). Runs in the background; studio_job follows it.',
@@ -569,14 +658,14 @@ export function toolDefs(ctx, avail = {}) {
     },
     {
       name: 'game_demo', title: 'See a working game',
-      description: 'Step 2: a live multiplayer game on Homie Arcade to play right now, made with this same toolkit, with NOTHING copied into the studio. Give the person the Play link: two browser tabs (or a phone and a computer) are two players in the same room; bots fill the empty seats. Copy a starter into the studio (game_make) only if they ask.',
+      description: 'Step 2: a live multiplayer game on Homie Arcade to play right now, made with this same toolkit, with NOTHING copied into the studio. Give the person the Play link: THEY open it (the link in your reply, or Play on a card); never open a browser or run a command to open it yourself. Two browser tabs (or a phone and a computer) are two players in the same room; bots fill the empty seats. Copy a starter into the studio (game_make) only if they ask.',
       inputSchema: { type: 'object', properties: { ...STUDIO_ARG } },
       annotations: { title: 'See a working game', ...RO, openWorldHint: true },
       run: async (a) => {
         const root = ctx.root(a.studio, { need: false });
         const r = await demoGames();
         if (root) ctx.note(root).demo = true;
-        return ok(formatDemo(r), { kind: 'demo', ...r });
+        return ok(`${formatDemo(r)}\n\nFor you, the AI: give the person this Play link in your reply; they open it themselves. Do not open a browser or run any command to open it.`, { kind: 'demo', ...r });
       },
     },
     {
@@ -705,7 +794,7 @@ export function toolDefs(ctx, avail = {}) {
         return ok([
           `${slow ? 'Starting' : 'Running'} here: ${url}/${games.length ? '' : ' (the home page: "First game coming soon")'}`,
           ...games.map((x) => `  ${x.name ?? x.id}: ${url}/${x.id}/play`),
-          g ? `Open ${url}/${g.id}/play in two browser tabs: two players, one room.` : '',
+          g ? `The person opens ${url}/${g.id}/play in two browser tabs: two players, one room. Give them the address; do not open a browser for them.` : 'Give the person the address; do not open a browser for them.',
         ].filter(Boolean).join('\n'), { kind: 'preview', url, games: games.map((x) => ({ id: x.id, play: `${url}/${x.id}/play` })) });
       },
     },
@@ -901,7 +990,7 @@ export function toolDefs(ctx, avail = {}) {
       annotations: { title: 'Read a file', ...RO },
       run: async (a) => {
         const r = readStudioFile(ctx.root(a.studio), a.path, { offset: a.offset, limit: a.limit });
-        if (r.image) return { content: [{ type: 'image', data: r.image.data, mimeType: r.image.mimeType }, { type: 'text', text: `${r.rel} (${Math.round(r.bytes / 1024)} KB)` }] };
+        if (r.image) return { content: [{ type: 'image', data: r.image.data, mimeType: r.image.mimeType }, { type: 'text', text: `${r.rel} (${r.shrunk ? `a smaller JPEG copy, ${Math.round(r.bytes / 1024)} KB, of a ${Math.round(r.from / 1024)} KB picture; the file is unchanged` : `${Math.round(r.bytes / 1024)} KB`})` }] };
         return ok(`${r.rel} (lines ${r.from}-${r.to} of ${r.lines}${r.more ? '; more with offset' : ''})\n${r.text}`);
       },
     },

package/lib/mcp.mjs

@@ -22,6 +22,7 @@ import { join } from 'node:path';
 import { PACKAGE_ROOT } from './studio.mjs';
 import { StudioContext, UI, availability, toolDefs } from './mcp-tools.mjs';
 import { stopAllJobs, toolPath } from './jobs.mjs';
+import { shrinkPictureData } from './pictures.mjs';
 import { STUDIO_VERSION } from './version.mjs';
 
 export const PROTOCOLS = ['2025-11-25', '2025-06-18', '2025-03-26', '2024-11-05'];
@@ -39,8 +40,12 @@ A new studio follows one checklist, in order and never ahead. Show it in your fi
 6. Playtest it (playtest), then put it online: studio_deploy with plan: true first (say what it creates and costs, free), cloudflare_login when not signed in (they approve once in their browser), studio_deploy, then studio_publish.
 If they ask for everything at once, show the list, make your own choices for steps 2 to 4 in one line each, and go on.
 
+If studio_scaffold finds an earlier folder of the studio's name that is not a studio, ask the person whether to fold its premise in (studio_fold), and remove it only with a second yes.
+
 A studio made elsewhere (on a phone, with Deploy to Cloudflare, so it lives on GitHub): studio_open with its repo clones it into the studios folder with this computer's own GitHub sign-in; github_login signs the computer in with GitHub's one-time code. Never ask for a token.
 
+Links are the person's to open: give them in your reply (the cards have their own buttons). Never open a browser or run a command such as open to open one yourself.
+
 Long work (npm install, check, playtest, deploy, renders) runs in the background: the tool answers at once with a card that follows it, and build_progress or studio_job reads where it is. studio_guide has Homie's full guide for each job (game, plan, port, playtest, publish, music, sound, art, video). Never put a key or password in a file or the chat. If Homie's homie.rocks connector is connected too, its tools of the same names say what to run; these run it.`;
 
 const CARD_FILES = { [UI.setup]: 'setup.js', [UI.build]: 'build.js', [UI.studio]: 'studio.js', [UI.codex]: 'codex.js' };
@@ -64,6 +69,52 @@ export function cardCsp(uri) {
   return { connectDomains: [], resourceDomains: [] };
 }
 
+/*
+ * ONE ANSWER, AT MOST RESULT_MAX. The Claude desktop app refuses a tool result over 1 MB. Every tools/call answer goes
+ * through fitResult on its way out: pictures first (a smaller copy, else left out), then the card's pictures, then the
+ * text (cut, and saying so), and last the card's data itself. What was left out is said in the answer's text.
+ */
+export const RESULT_MAX = 900_000;
+const sizeOf = (r) => JSON.stringify(r).length;
+
+/** Every data: URL in a card's data (a feed's preview, a codex's art, a studio's covers) taken out. */
+function withoutDataUrls(v) {
+  if (typeof v === 'string') return v.startsWith('data:') && v.length > 1024 ? null : v;
+  if (Array.isArray(v)) return v.map(withoutDataUrls);
+  if (v && typeof v === 'object') return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, withoutDataUrls(x)]));
+  return v;
+}
+
+export function fitResult(result, { max = RESULT_MAX, shrink = shrinkPictureData } = {}) {
+  if (!result || typeof result !== 'object' || sizeOf(result) <= max) return result;
+  const r = JSON.parse(JSON.stringify(result));
+  const said = [];
+  const content = Array.isArray(r.content) ? r.content : (r.content = []);
+  for (let i = 0; i < content.length && sizeOf(r) > max; i++) {
+    const c = content[i];
+    if (c?.type !== 'image') continue;
+    const small = shrink(c.data, c.mimeType);
+    if (small && small.data.length < c.data.length) { content[i] = { ...c, ...small }; said.push('a picture went as a smaller copy'); }
+    else { content[i] = { type: 'text', text: '(A picture was left out: too big for one answer.)' }; said.push('a picture was left out'); }
+  }
+  if (sizeOf(r) > max && r.structuredContent) { r.structuredContent = withoutDataUrls(r.structuredContent); said.push('the card shows no pictures this time'); }
+  if (sizeOf(r) > max) {
+    // The longest text goes down to what fits, cut at a line's end.
+    const texts = content.filter((c) => c?.type === 'text' && typeof c.text === 'string').sort((a, b) => b.text.length - a.text.length);
+    for (const t of texts) {
+      const over = sizeOf(r) - max;
+      if (over <= 0) break;
+      const keep = Math.max(0, t.text.length - over - 400);
+      const cut = t.text.slice(0, keep);
+      t.text = `${cut.slice(0, Math.max(cut.lastIndexOf('\n'), Math.floor(keep * 0.9)))}\n…`;
+      said.push('the text was cut');
+    }
+  }
+  if (sizeOf(r) > max && r.structuredContent) { delete r.structuredContent; said.push('the card had no room for its data'); }
+  if (said.length) content.push({ type: 'text', text: `(This answer was over ${Math.round(max / 1000)} KB, the most one answer may be here: ${[...new Set(said)].join('; ')}.)` });
+  return r;
+}
+
 export const PROMPTS = [
   { name: 'new-studio', title: 'Set up a game studio', description: 'Make a game studio on this computer and go through Homie\'s new-studio checklist.', arguments: [{ name: 'name', description: 'The studio\'s name', required: false }] },
   { name: 'make-multiplayer', title: 'Make my game multiplayer', description: 'Port an existing single-player web game on this computer into a studio.', arguments: [{ name: 'folder', description: 'The game\'s folder', required: true }] },
@@ -122,7 +173,7 @@ export async function serveMcp({ studios = null, skills = null, cwd = process.cw
           let result;
           try { result = await tool.run(params?.arguments ?? {}); } catch (e) { result = { content: [{ type: 'text', text: e instanceof Error ? e.message : String(e) }], isError: true }; }
           log(`${name} ${result?.isError ? 'failed' : 'ok'} in ${Date.now() - t0} ms`);
-          reply(result);
+          reply(fitResult(result));
           // A media provider set up meanwhile adds its tool.
           const before = names;
           avail = availability();

package/lib/pictures.mjs

@@ -0,0 +1,67 @@
+/**
+ * PICTURES SMALL ENOUGH FOR ONE ANSWER. The Claude desktop app refuses a tool result over 1 MB, and a picture travels
+ * as base64 (a third bigger). So a picture a tool hands back is at most PICTURE_MAX raw: a bigger one becomes a
+ * smaller JPEG copy (ffmpeg, else macOS's own sips), stepping down in width until it fits; with neither, it is
+ * refused, naming the file, so the person can open it themselves. The original file is never changed.
+ */
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { extname, join } from 'node:path';
+import { which } from './jobs.mjs';
+
+export const PICTURE_MAX = 600 * 1024;
+const SOURCE_MAX = 40 * 1024 * 1024;
+export const PICTURE_TYPES = { '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.webp': 'image/webp', '.gif': 'image/gif' };
+const WIDTHS = [1600, 1200, 900, 640, 480];
+
+/** Which shrinker this computer has: { kind, bin } or null. */
+export function shrinker() {
+  const ff = which(process.platform === 'win32' ? 'ffmpeg.exe' : 'ffmpeg');
+  if (ff) return { kind: 'ffmpeg', bin: ff };
+  if (process.platform === 'darwin' && existsSync('/usr/bin/sips')) return { kind: 'sips', bin: '/usr/bin/sips' };
+  return null;
+}
+
+function shrinkTo(tool, src, out, width) {
+  const args = tool.kind === 'ffmpeg'
+    ? ['-v', 'error', '-y', '-i', src, '-frames:v', '1', '-vf', `scale='min(${width},iw)':-2`, '-q:v', '6', out]
+    : ['-s', 'format', 'jpeg', '-s', 'formatOptions', '70', '-Z', String(width), src, '--out', out];
+  const r = spawnSync(tool.bin, args, { encoding: 'utf8', timeout: 30_000 });
+  return r.status === 0 && existsSync(out);
+}
+
+/**
+ * A picture file as MCP image content: { mimeType, data (base64), bytes, shrunk, width? }. Throws, naming `label`,
+ * when it cannot be made small enough here.
+ */
+export function pictureFor(path, { label = path, max = PICTURE_MAX, tool = shrinker() } = {}) {
+  const size = statSync(path).size;
+  const mime = PICTURE_TYPES[extname(path).toLowerCase()] ?? 'image/png';
+  if (size <= max) return { mimeType: mime, data: readFileSync(path).toString('base64'), bytes: size, shrunk: false };
+  if (size > SOURCE_MAX) throw new Error(`${label} is ${Math.round(size / 1024 / 1024)} MB: too big to look at here; the person can open it themselves`);
+  if (!tool) throw new Error(`${label} is ${Math.round(size / 1024)} KB, more than the ${Math.round(max / 1024)} KB a picture may be in one answer, and this computer has no ffmpeg (or sips) to make a smaller copy. The person can open it themselves: ${label}`);
+  const tmp = mkdtempSync(join(tmpdir(), 'homie-picture-'));
+  try {
+    for (const width of WIDTHS) {
+      const out = join(tmp, `w${width}.jpg`);
+      if (!shrinkTo(tool, path, out, width)) break;
+      const bytes = statSync(out).size;
+      if (bytes <= max) return { mimeType: 'image/jpeg', data: readFileSync(out).toString('base64'), bytes, shrunk: true, width, from: size };
+    }
+  } finally { rmSync(tmp, { recursive: true, force: true }); }
+  throw new Error(`${label} could not be made smaller than ${Math.round(max / 1024)} KB here; the person can open it themselves: ${label}`);
+}
+
+/** A picture already in an answer (base64): a smaller copy that fits, or null when there is none to be had. */
+export function shrinkPictureData(data, mimeType, { max = PICTURE_MAX, tool = shrinker() } = {}) {
+  if (!tool || typeof data !== 'string') return null;
+  const ext = Object.entries(PICTURE_TYPES).find(([, m]) => m === mimeType)?.[0] ?? '.png';
+  const tmp = mkdtempSync(join(tmpdir(), 'homie-picture-'));
+  try {
+    const src = join(tmp, `in${ext}`);
+    writeFileSync(src, Buffer.from(data, 'base64'));
+    const pic = pictureFor(src, { max, tool });
+    return { mimeType: pic.mimeType, data: pic.data };
+  } catch { return null; } finally { rmSync(tmp, { recursive: true, force: true }); }
+}

package/lib/progress.mjs

@@ -83,6 +83,17 @@ const IMAGE_TYPES = { '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image
 
 const now = () => new Date().toISOString();
 /** Plain text of at most `max` characters: no control characters, trimmed. */
+/**
+ * Plain text of at most `max` characters, cut at the end of a word with "…" when it is longer: never mid-word, and
+ * never mid-number (a log line said "bots, up to)" once, its "6" cut off).
+ */
+export function clip(value, max) {
+  const t = plain(value, Number.MAX_SAFE_INTEGER);
+  if (t.length <= max) return t;
+  const cut = t.slice(0, max - 1);
+  const space = cut.lastIndexOf(' ');
+  return `${(space > max * 0.5 ? cut.slice(0, space) : cut).replace(/[\s,;:(\u2013\u2014-]+$/u, '')}…`;
+}
 export const plain = (value, max) => String(value ?? '').replace(/[\u0000-\u001f\u007f-\u009f\u2028\u2029]+/g, ' ').replace(/\s+/g, ' ').trim().slice(0, max);
 const dir = (root) => join(root, PROGRESS_DIR);
 const docPath = (root, id) => join(dir(root), `${id}.json`);
@@ -219,7 +230,7 @@ export async function flushProgress(ms = 6000) {
 /* ------------------------------------------------------------------ the document */
 
 function pushLog(d, text) {
-  d.log = [...(d.log ?? []), { at: now(), text: plain(text, LIMITS.logLine) }].slice(-LIMITS.logLines);
+  d.log = [...(d.log ?? []), { at: now(), text: clip(text, LIMITS.logLine) }].slice(-LIMITS.logLines);
 }
 
 function mutateDoc(root, id, fn) {
@@ -268,7 +279,8 @@ export class Feed {
       if (note !== undefined) s.note = plain(note, LIMITS.note);
       if (state === 'failed' && note) doc.error = plain(note, LIMITS.note);
       if (state === 'running' || state === 'done') doc.error = null;
-      pushLog(doc, `${s.label}: ${state}${note ? ` (${plain(note, 100)})` : ''}`);
+      // The note is cut at a word's end, inside its own brackets, so the line keeps its closing ")".
+      pushLog(doc, `${s.label}: ${state}${note ? ` (${clip(note, LIMITS.logLine - s.label.length - state.length - 5)})` : ''}`);
     }, { soon: true });
     heartbeat(this.root, this.id, d?.stages?.some((s) => s.state === 'running') && d.state === 'running');
     return d;

package/lib/template-history.json

@@ -353,6 +353,33 @@
      "## Beta": "9d02638207a26e73"
     }
    }
+  },
+  "0.14.3": {
+   "files": {
+    "CLAUDE.md": "ddf2b2a0376202f6",
+    "README.md": "684b3cca8001673c",
+    "HANDOFF.md": "ce7a8fd91c6bbee2",
+    "games/README.md": "5ad32fe80c61f117",
+    "music/README.md": "b8a828de9311bd28",
+    "videos/README.md": "70614388cbb203c7",
+    "posts/README.md": "37841aae476bd540",
+    "site/README.md": "ca131cd0472464fb",
+    "site/src/worker.mjs": "ca3f1630f2420ad3"
+   },
+   "sections": {
+    "AGENTS.md": {
+     "(intro)": "214aa46eb3a895d5",
+     "## Layout": "f14d641159480e6c",
+     "## Commands (all through the pinned CLI in node_modules)": "e579cd6ce3ce342a",
+     "## The site": "7c1618431bae6324",
+     "## Making games": "63069b31c87a2aa2",
+     "## The Game Codex and progress": "0738ef719cef3a4c",
+     "## Running live games (the back office)": "f0566f07cff04113",
+     "## Continuing a build from the Claude app": "0d68081e924ca419",
+     "## Rules": "969318425c99f5a5",
+     "## Beta": "9d02638207a26e73"
+    }
+   }
   }
  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homie-rocks/studio",
-  "version": "0.14.2",
+  "version": "0.14.3",
   "description": "A studio for games, music and video on its own Cloudflare: scaffold, multiplayer starters on the netplay contract, a port toolkit that makes existing single-player web games multiplayer, the site Worker with public rooms (Table/Lobby Durable Objects and D1, all on the free Workers plan, no payment method), a site with the hub's sections (Home, Games, Music, Videos, Rooms, Posts with feeds) in the studio's own look, an epic landing page for every game, optional R2 storage for large media, deploy, and the homie.rocks directory.",
   "type": "module",
   "license": "Apache-2.0",

package/worker/version.mjs

@@ -1,2 +1,2 @@
 /** The @homie-rocks/studio version this Worker code is (package.json's; a test keeps them equal). Cache-busts /_homie/site.js. */
-export const STUDIO_VERSION_TAG = '0.14.2';
+export const STUDIO_VERSION_TAG = '0.14.3';