@homie-rocks/studio 0.29.0 → 0.30.1

package/CHANGELOG.md

@@ -5,7 +5,7 @@ What changed in each release of Homie's open parts, newest first:
 - **`@homie-rocks/studio`**: the `homie-studio` command, your studio's site Worker, its multiplayer rooms (the
   netplay contract), the port kit and the starter games. Every version is on npm, and Homie for Claude Desktop
   (`homie-studio-<version>.mcpb` on each GitHub release) is built from it.
-- **The Homie plugin** for Claude Code and Codex: its skills. It ships from this repository's marketplace with its
+- **The Homie plugin** for Claude Code, Codex and Grok: its skills. It ships from this repository's marketplace with its
   own version number, given beside each studio version below.
 
 Each version says what you can now do (**Added**), what works differently (**Changed**), what was broken and is
@@ -17,9 +17,52 @@ To bring a studio up to date, tell Claude: "Upgrade my studio to the newest Homi
 `npx -y @homie-rocks/studio@latest upgrade`, which shows what's new since the version your studio pins (from this
 file) and what the upgrade would change, and changes nothing until you agree.
 
+## [0.30.1] - 2026-10-04
+
+**Plugin 0.31.1** · [#47](https://github.com/homie-rocks/homie/pull/47)
+
+Fixes from a filmed first run in the Claude desktop app: Claude tells you once to choose Always allow and what to do when a step sits on a spinner, the deploy plan's card fills in, and a starter is changed in a few large edits instead of twenty small ones.
+
+### Added
+
+- `file_edit` (Homie for Claude Desktop, and any client of `homie-studio mcp`) takes every change to a file in one call: `edits`, a list of `{ old, new }` applied in order, all of them or none. A miss says which edit it was and leaves the file as it was. One change with `old` and `new` works as before.
+- The build card draws a deploy plan: what going online creates on your own Cloudflare, what is there already and what it costs, before anything is made.
+
+### Changed
+
+- In the Claude desktop app, Claude says once, in its first words to you: the app asks before each Homie Studio tool, **Always allow** lets a build run without a click at every step (the filmed first build made about fifty tool calls), and if a step sits on a spinner with nothing to click, a request is waiting out of sight: ⌘ Return (Ctrl+Enter on Windows) allows it, and scrolling the chat can bring it into view. Claude also writes a line of text between a card and its next tool call, because a request that came straight after a card is the one the app has failed to draw. Only the desktop extension says any of this (its manifest starts the server with `HOMIE_STUDIO_EXTENSION=1`): in Claude Code, Codex, Grok and other MCP clients it is not true, and nothing is said.
+- The README's desktop section, `desktop/README.md` and the extension's install screen say the same in a sentence.
+- Fewer, larger edits. The `game` skill, the note above every guide in `homie-studio mcp`, `game_make` and `game_plan` ask the AI to read a file once and make every change to it in one call. A first build spent about twenty single edits on one starter file and ran into the app's limit of tool calls in a turn, so the person had to say "keep going".
+- `setup_status` takes the name of a studio that is not made yet as `studio`: the card and the checklist are then the new studio's.
+
+### Fixed
+
+- The deploy plan's card stayed on a grey "Loading" skeleton for good. `studio_deploy` with `plan: true` answers with a plan, not a build, and the build card knew only builds. A card whose tool answered with something else (a plan, a job still running, plain words) now shows that answer; "Loading" is only for a tool that has not answered yet.
+- With one studio already in the Studios folder, the setup card for a second studio led with the first one's name and checklist.
+
+### Upgrade notes
+
+- Homie for Claude Desktop: install this version's `homie-studio.mcpb` over the one you have. A studio needs no change.
+
+## [0.30.0] - 2026-10-03
+
+**Plugin 0.31.0** · [#45](https://github.com/homie-rocks/homie/pull/45) · [release-2026-10-03-studio-0.30.0](https://github.com/homie-rocks/homie/releases/tag/release-2026-10-03-studio-0.30.0)
+
+Grok can set up a studio and run it with the same holds as Claude Code and Codex.
+
+### Added
+
+- `homie-studio setup attach <hs_…> --client grok` and `homie-studio handoff <hb_…> --client grok`. A Grok Bot in the studio folder checks the repository in. The directory is told the chat is Grok. Claude and Codex pass `--client claude` or `--client codex`; with no `--client` the words stay "the chat".
+- Homie's hooks for Grok Build (`plugins/homie/.grok-plugin/plugin.json`, `hooks/grok.json`, `hooks/grok.mjs`). They ask `hooks/lib/holds.mjs`, the module the Claude Code mod and the Codex hooks already ask, so the three hold the same calls with the same words. A held call waits for your own `proceed <code>`. Secrets are taken out of what Grok reads.
+- A new studio's home band says **Connect this chat**, for Claude, Codex or Grok. Grok has no Cloudflare connector: approving Cloudflare in the browser is still your step.
+
+### Changed
+
+- The plugin manifests (Claude Code, Codex, Grok and `plugin.json`) name plugin 0.31.0 and say the same thing. `plugins/homie/test/manifests.test.mjs` checks the Grok manifest with the others.
+
 ## [0.29.0] - 2026-10-03
 
-**Plugin 0.30.0** · [#44](https://github.com/homie-rocks/homie/pull/44)
+**Plugin 0.30.0** · [#44](https://github.com/homie-rocks/homie/pull/44) · [release-2026-10-03-studio-0.29.0](https://github.com/homie-rocks/homie/releases/tag/release-2026-10-03-studio-0.29.0)
 
 The Lounge: a community room on your own studio, with play nights, moderators, live rooms and "show what you made" cards, and chat history you can turn on.
 

package/README.md

@@ -83,8 +83,8 @@ The button copies the public template (`template/` in this repository, exactly w
 writes) into the person's GitHub, makes the Worker, the D1 database and the rooms on their Cloudflare account,
 and connects Workers Builds. The site goes live with its own home page ("First game coming soon": no starter game
 is put in a studio unless the person asks for one), and its Home has a
-**Connect to Claude** band: one tap links it to the Claude chat that set it up (the Homie MCP tool `studio_setup`).
-In the Claude Code session that works in the repository, `homie-studio setup attach <hs_…>` then gives the studio
+**Connect this chat** band: one tap links it to the chat that set it up (the Homie MCP tool `studio_setup`).
+In the session that works in the repository, `homie-studio setup attach <hs_…> [--client claude|codex|grok]` then gives the studio
 the name chosen in the chat and removes the band.
 
 **The site claims itself in the directory.** The homie.rocks directory lists a studio only when its site serves

package/bin/homie-studio.mjs

@@ -173,10 +173,12 @@
  *                                         into it (stage, each check going green, a preview picture) and stop
  *                                         when asked. Without one, nothing changes.
  *
- *   homie-studio handoff <hb_…>           (a Claude Code session started from the Claude app with one line, "Continue building
+ *   homie-studio handoff <hb_…> [--client claude|codex|grok]
+ *                                          (a session started from the chat with one line, "Continue building
  *                                          <Studio>: build hb_…": fetch the person's brief, check in for a new studio, take
  *                                          the build so the chat's card follows it, and print the steps; HANDOFF.md)
- *   homie-studio setup attach <hs_…>      (this repository is the studio the Claude app's setup card is making: say so, once,
+ *   homie-studio setup attach <hs_…> [--client claude|codex|grok]
+ *                                          (this repository is the studio the chat's setup card is making: say so, once,
  *                                          learn its live address, and give a template copy its real name)
  *   homie-studio setup --via stripe-projects [--with elevenlabs] [--accept-tos] [--dry-run]
  *                                         (a prototype, 0.24.3: Cloudflare, and ElevenLabs with --with, made or linked
@@ -711,14 +713,14 @@ async function main() {
   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);
-  if (cmd === 'setup' && sub === 'attach') return setupAttach(root, positional[2], { homie: flags.get('homie') });
+  if (cmd === 'setup' && sub === 'attach') return setupAttach(root, positional[2], { homie: flags.get('homie'), client: flags.get('client') });
   if (cmd === 'setup' && flags.has('via')) {
     if (flags.get('via') !== 'stripe-projects') return { ok: false, command: 'setup', why: '--via stripe-projects is the one other way this version knows (the default is npx wrangler login)' };
     const extra = String(flags.get('with') ?? '').split(',').map((x) => x.trim()).filter(Boolean);
     if (extra.some((x) => x !== 'elevenlabs')) return { ok: false, command: 'setup', why: '--with takes elevenlabs (Cloudflare is always set up)' };
     return setupViaProjects(root, { withElevenlabs: extra.includes('elevenlabs'), acceptTos: flags.has('accept-tos'), dryRun: flags.has('dry-run'), log });
   }
-  if (cmd === 'handoff') return handoff(root, sub, { homie: flags.get('homie') });
+  if (cmd === 'handoff') return handoff(root, sub, { homie: flags.get('homie'), client: flags.get('client') });
   if (cmd === 'port' && sub === 'import') return importPort(root, positional[2], flags.get('id'), { name: flags.get('name'), mode: flags.get('mode') });
   if (cmd === 'port' && sub === 'check') {
     const game = positional[2] ?? listGames(root)[0]?.id;

package/lib/client.mjs

@@ -0,0 +1,19 @@
+/**
+ * Which chat is building the studio. Named only when the session says so (`--client`, or HOMIE_CLIENT).
+ * Anything else is "the chat": never a guess that it is Claude. Grok has no Cloudflare connector and no
+ * Claude Code window; `--client grok` is how a Grok Bot checks a repository in.
+ */
+const KNOWN = {
+  claude: { id: 'claude', card: "the Claude app's card", connect: 'Connect this chat' },
+  codex: { id: 'codex', card: "Codex's card", connect: 'Connect this chat' },
+  grok: { id: 'grok', card: "Grok's card", connect: 'Connect this chat' },
+  chat: { id: 'chat', card: 'the setup card', connect: 'Connect this chat' },
+};
+const ALIAS = { 'claude-code': 'claude', 'claude-app': 'claude', 'grok-bot': 'grok', grokbot: 'grok' };
+
+/** @param {string | null | undefined} input  `--client`, or null to read HOMIE_CLIENT */
+export function studioClient(input, env = process.env) {
+  const raw = String(input ?? env.HOMIE_CLIENT ?? '').trim().toLowerCase();
+  const id = ALIAS[raw] ?? raw;
+  return KNOWN[id] ?? KNOWN.chat;
+}

package/lib/doctor.mjs

@@ -152,7 +152,7 @@ export async function setupStatus({
   {
     const fixConnector = {
       who: 'person',
-      say: 'Turn the Homie connector on. Claude Code: run /plugin, install or enable "homie" (marketplace homie-rocks/homie), then /mcp shows homie connected. Codex: install the Homie plugin from the same marketplace. The Claude app: Settings, Connectors, Add custom connector, https://homie.rocks/mcp; then its setup card (studio_setup) makes the studio on your own Cloudflare and GitHub in three taps.',
+      say: 'Turn the Homie connector on. Claude Code: run /plugin, install or enable "homie" (marketplace homie-rocks/homie), then /mcp shows homie connected. Codex: install the Homie plugin from the same marketplace. Grok Build: the same plugin (.grok-plugin/plugin.json). The Claude app, or Grok: add the connector https://homie.rocks/mcp; its setup card (studio_setup) makes the studio on your own Cloudflare. Grok has no Cloudflare connector: you still approve Cloudflare in the browser. A Grok Bot on this computer runs the checklist and checks in with setup attach <hs_…> --client grok.',
     };
     let state; let detail;
     if (net.blocked) { state = 'act'; detail = `the network proxy of this machine refused ${new URL(directory).host}`; }
@@ -162,7 +162,7 @@ export async function setupStatus({
     else { state = 'unknown'; detail = net.ok ? `${new URL(directory).host} answers; your AI knows whether its Homie tools (studio_scaffold) are here` : `this computer's request to the directory failed: ${net.why}`; }
     rows.push({
       id: 'connector', label: 'Homie connector', need: 'required', state, detail,
-      unlocks: 'making the studio with the right toolkit version, listing games in the homie.rocks directory, and the cards in the Claude app',
+      unlocks: 'making the studio with the right toolkit version, listing games in the homie.rocks directory, and the setup cards',
       fix: state === 'ok' ? null : net.blocked
         ? { who: 'person', say: `In claude.ai/code, open this environment's settings, set Network access to Custom, add ${new URL(directory).host} (keep the default package managers), and start a new session.` }
         : said === 'no' || net.ok ? fixConnector : null,
@@ -174,13 +174,13 @@ export async function setupStatus({
     const local = root ? readLocal(root) : {};
     const created = studio?.cloudflare?.created ?? [];
     const deployed = Boolean(local.deployedAt || created.some((c) => String(c).startsWith('worker:')));
-    // A studio the Claude app's setup card made (`setup attach` wrote connectedAt): Cloudflare's Deploy button made
+    // A studio the setup card made (`setup attach` wrote connectedAt): Cloudflare's Deploy button made
     // it on the person's account and Workers Builds deploys every merge, so no sign-in is needed on this computer.
     const attached = Boolean(local.connectedAt);
     const signedIn = attached || who.signedIn === true ? 'ok' : who.signedIn === false ? 'act' : 'later';
     const verified = deployed || attached ? 'ok' : local.needs === 'cloudflare-verify-email' ? 'act' : 'later';
     const parts = attached ? [
-      { label: 'connected', state: 'ok', detail: 'through the Claude app\'s setup card (Deploy to Cloudflare); Workers Builds deploys every merge' },
+      { label: 'connected', state: 'ok', detail: 'through the setup card (Deploy to Cloudflare); Workers Builds deploys every merge' },
       { label: 'email verified', state: 'ok', detail: 'the site is live' },
     ] : [
       { label: 'signed in', state: signedIn, detail: who.signedIn === true ? (who.how ?? `${who.accounts ?? 1} account${who.accounts === 1 || who.accounts === null || who.accounts === undefined ? '' : 's'}`) : who.signedIn === false ? 'not signed in' : root ? (who.why ?? 'run npm install in the studio, then this again') : 'checked once the studio exists (it brings its own Wrangler)' },

package/lib/files.mjs

@@ -10,7 +10,7 @@ import { dirname, extname, join, relative, resolve, sep } from 'node:path';
 import { PICTURE_MAX, PICTURE_TYPES, pictureFor } from './pictures.mjs';
 
 // 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 });
+export const FILE_LIMITS = Object.freeze({ write: 2 * 1024 * 1024, read: 400 * 1024, image: PICTURE_MAX, lines: 2000, list: 600, matches: 200, edits: 100 });
 const IMAGES = PICTURE_TYPES;
 const SKIP_DIRS = new Set(['node_modules', '.git', '.wrangler', '.studio', 'dist']);
 
@@ -112,19 +112,33 @@ export function writeStudioFile(root, path, content) {
   return { rel, bytes: Buffer.byteLength(text), created: !existed };
 }
 
-export function editStudioFile(root, path, oldText, newText, { all = false } = {}) {
+/**
+ * Replace exact text in a file. One change (`oldText`, `newText`, `all`), or several in one call (`edits`: a list of
+ * { old, new, all? }), applied in order to the text in memory and written once: all of them, or none. A change that
+ * does not match says which one it was, and the file is left as it was.
+ */
+export function editStudioFile(root, path, oldText, newText, { all = false, edits = null } = {}) {
   const { abs, rel } = studioPath(root, path, { write: true });
   if (!existsSync(abs)) throw new Error(`${rel} does not exist (file_write makes a new file)`);
-  const was = readFileSync(abs, 'utf8');
-  const from = String(oldText ?? '');
-  if (!from) throw new Error('old is the exact text to replace (it cannot be empty)');
-  const count = was.split(from).length - 1;
-  if (!count) throw new Error(`the text to replace is not in ${rel} (it must match exactly, spaces and line breaks too)`);
-  if (count > 1 && !all) throw new Error(`the text to replace is in ${rel} ${count} times: give more of it so it is unique, or all: true`);
-  const next = all ? was.split(from).join(String(newText ?? '')) : was.replace(from, () => String(newText ?? ''));
+  const list = Array.isArray(edits) && edits.length ? edits : [{ old: oldText, new: newText, all }];
+  if (list.length > FILE_LIMITS.edits) throw new Error(`at most ${FILE_LIMITS.edits} edits in one call`);
+  const many = list.length > 1;
+  let next = readFileSync(abs, 'utf8');
+  let replaced = 0;
+  list.forEach((e, i) => {
+    const from = String(e?.old ?? '');
+    const which = many ? `edit ${i + 1} of ${list.length} (${JSON.stringify(from.slice(0, 60))}${from.length > 60 ? '…' : ''}): ` : '';
+    const none = many ? '; nothing was changed' : '';
+    if (!from) throw new Error(`${which}old is the exact text to replace (it cannot be empty)${none}`);
+    const count = next.split(from).length - 1;
+    if (!count) throw new Error(`${which}the text to replace is not in ${rel} (it must match exactly, spaces and line breaks too${many ? '; an earlier edit in this call may have changed it' : ''})${none}`);
+    if (count > 1 && e.all !== true) throw new Error(`${which}the text to replace is in ${rel} ${count} times: give more of it so it is unique, or all: true${none}`);
+    next = e.all === true ? next.split(from).join(String(e.new ?? '')) : next.replace(from, () => String(e.new ?? ''));
+    replaced += e.all === true ? count : 1;
+  });
   if (Buffer.byteLength(next) > FILE_LIMITS.write) throw new Error(`at most ${FILE_LIMITS.write / 1024 / 1024} MB a file`);
   writeFileSync(abs, next);
-  return { rel, replaced: all ? count : 1 };
+  return { rel, replaced, edits: list.length };
 }
 
 /** Lines matching a regular expression, in the studio's text files (never node_modules, git, builds or .studio). */

package/lib/handoff.mjs

@@ -15,6 +15,7 @@ import { request } from './net.mjs';
 import { startProgress } from './progress.mjs';
 import { spawnSync } from 'node:child_process';
 import { studioRepo } from './repo.mjs';
+import { studioClient } from './client.mjs';
 
 /** The repository this checkout IS (its origin remote), even Homie's engine one: the session must be in the studio's. */
 function originRepo(root) {
@@ -36,13 +37,13 @@ const line = (v, max) => String(v ?? '').replace(/[\x00-\x1f\x7f]+/g, ' ').repla
 const lines = (v, max) => String(v ?? '').split(/\r?\n/).map((l) => line(l, max)).filter(Boolean).join('\n').slice(0, max);
 
 /** The steps for a kind of build, in this toolkit's commands (the brief says what; these say how). */
-export function stepsFor(h, { games = [] } = {}) {
+export function stepsFor(h, { games = [], client = 'chat' } = {}) {
   const id = ID.test(String(h.id ?? '')) ? h.id : null;
   const has = id && games.includes(id);
   const q = (s) => JSON.stringify(String(s));
   const work = {
     setup: [
-      'This studio was just set up from the Claude app. Go through the new-studio checklist with the person, one step at a time and never ahead (the plugin\'s studio-setup skill): it has no game yet, and its home page says "First game coming soon".',
+      `This studio was just set up from ${client === 'grok' ? 'Grok' : client === 'codex' ? 'Codex' : client === 'claude' ? 'the Claude app' : 'this chat'}. Go through the new-studio checklist with the person, one step at a time and never ahead (the plugin's studio-setup skill): it has no game yet, and its home page says "First game coming soon".`,
       'See a working game: `npx --no-install homie-studio demo` names a live one on Homie Arcade; copy a starter in only if they ask.',
       'One small change from one sentence of theirs (the studio\'s colours in site/theme.json, a tagline in studio.json, or a first post in posts/), then plan their game into its Game Codex (`npx --no-install homie-studio codex new <id> --name "<Name>"`) before any game is made.',
     ],
@@ -67,16 +68,17 @@ export function stepsFor(h, { games = [] } = {}) {
   ];
 }
 
-export async function handoff(root, build, { homie, fetchFn = globalThis.fetch, attach = startProgress, checkIn = setupAttach, repoOf = originRepo } = {}) {
+export async function handoff(root, build, { homie, client, fetchFn = globalThis.fetch, attach = startProgress, checkIn = setupAttach, repoOf = originRepo } = {}) {
   const studio = readStudio(root);
+  const who = studioClient(client);
   // "Continue building <Studio>: setup hs_…": a studio being set up, before any build: check in, then the checklist.
   if (SETUP.test(String(build ?? ''))) {
-    const r = await checkIn(root, build, { homie });
+    const r = await checkIn(root, build, { homie, client: who.id === 'chat' ? null : who.id });
     if (!r.ok) return { ok: false, command: 'handoff', setup: build, why: r.why, ...(r.needs ? { needs: r.needs } : {}) };
     const h = { kind: 'setup', what: 'game', title: 'first steps', studio: r.name ?? studio.name, brief: '', setup: build };
-    return { ok: true, command: 'handoff', build: null, ...h, setup: { ok: true, message: r.message, renamed: r.renamed ?? [] }, attached: null, attachWhy: 'no build was opened in the chat yet (the setup card\'s Start building opens one)', steps: stepsFor(h) };
+    return { ok: true, command: 'handoff', build: null, ...h, client: who.id, setup: { ok: true, message: r.message, renamed: r.renamed ?? [] }, attached: null, attachWhy: 'no build was opened in the chat yet (the setup card\'s Start building opens one)', steps: stepsFor(h, { client: who.id }) };
   }
-  if (!BUILD.test(String(build ?? ''))) return { ok: false, command: 'handoff', why: 'the id from the one line the Claude app gave: hb_ (a build) or hs_ (a setup) and 32 hex digits' };
+  if (!BUILD.test(String(build ?? ''))) return { ok: false, command: 'handoff', why: `the id from the one line the chat gave: hb_ (a build) or hs_ (a setup) and 32 hex digits` };
   const directory = String(homie || studio.homie?.directory || 'https://homie.rocks').replace(/\/+$/, '');
   // lib/net.mjs: through the environment's proxy, and an honest reason when it fails (the directory's own words, or
   // the connection's error; only a refusal by the proxy names the network setting).
@@ -98,7 +100,7 @@ export async function handoff(root, build, { homie, fetchFn = globalThis.fetch,
   };
   let setup = null;
   if (h.setup) {
-    const r = await checkIn(root, h.setup, { homie: directory });
+    const r = await checkIn(root, h.setup, { homie: directory, client: who.id === 'chat' ? null : who.id });
     setup = { ok: r.ok, message: r.ok ? r.message : r.why, renamed: r.renamed ?? [] };
   }
   const taken = await attach(root, { attach: build, what: h.what, id: h.id, directory });
@@ -108,7 +110,7 @@ export async function handoff(root, build, { homie, fetchFn = globalThis.fetch,
     ok: true, command: 'handoff', build, ...h, setup,
     attached: taken.ok ? { feed: taken.build, shared: taken.shared?.build ?? build } : null,
     attachWhy: taken.ok ? null : taken.why,
-    steps: stepsFor(h, { games }),
+    steps: stepsFor(h, { games, client: who.id }),
   };
 }
 

package/lib/mcp-tools.mjs

@@ -54,6 +54,20 @@ export const HOMIE_UPDATES = 'https://homie.rocks/updates/?from=plugin';
 const inside = (base, p) => p === base || p.startsWith(base.endsWith(sep) ? base : `${base}${sep}`);
 const realOr = (p) => { try { return realpathSync(p); } catch { return resolve(p); } };
 
+/** In Homie for Claude Desktop: the extension's manifest starts the server with HOMIE_STUDIO_EXTENSION=1 (desktop/manifest.json). */
+export const inDesktopApp = (env = process.env) => env.HOMIE_STUDIO_EXTENSION === '1';
+
+/*
+ * A FIRST RUN IN THE CLAUDE DESKTOP APP (0.30.1). The app asks the person before every tool call of an extension:
+ * about fifty requests in one filmed first build, each a click, and nothing told the person that "Always allow"
+ * exists. Twice the app raised a request it did not draw (it came straight after a card, with no text between):
+ * the chat showed a spinner until the request timed out four minutes later, while the request's own key still
+ * answered it. That is the app's to fix; Homie's part is that the person is told, once, by the model, in its first
+ * reply. Only the desktop extension says this (inDesktopApp): in Claude Code, Codex, Grok or any other MCP client
+ * it would not be true.
+ */
+export const DESKTOP_APPROVALS = 'This is the Claude desktop app: it asks the person before each Homie Studio tool call. ONCE in a chat, in your first words to the person (skip it if you already said it in this chat), tell them in two short sentences of your own: (1) Claude will ask before it uses each Homie Studio tool, and choosing "Always allow" lets the build run without a click at every step; (2) if a step ever sits on a spinner for more than a few seconds with nothing to click, a request is waiting out of sight: Cmd+Return on a Mac (Ctrl+Enter on Windows) allows it once, and scrolling the chat can bring it into view (a request shows its keys beside its buttons). Do not repeat it later. And after a tool that shows a card (setup_status, studio_scaffold, game_codex, build_open, check, playtest, studio_deploy, …), write one short line of text before your next tool call: a request that came straight after a card, with no text between, is the one the app has failed to draw.';
+
 /** A folder as the Claude desktop app's settings give it: `${HOME}/Studios` arrives as written, so expand it here. */
 export function expandHome(value, home = homedir()) {
   const v = String(value ?? '').trim();
@@ -65,8 +79,10 @@ export function expandHome(value, home = homedir()) {
 /* ------------------------------------------------------------------ which studio */
 
 export class StudioContext {
-  constructor({ studiosDir = null, cwd = process.cwd(), skillsDir = null, waitMs = 40_000, directory = null, install = true } = {}) {
+  constructor({ studiosDir = null, cwd = process.cwd(), skillsDir = null, waitMs = 40_000, directory = null, install = true, desktop = inDesktopApp() } = {}) {
     this.install = install;
+    // Homie for Claude Desktop (the .mcpb): the one host these tools know asks the person before every call.
+    this.desktop = desktop === true;
     this.studiosDir = studiosDir ? expandHome(studiosDir) : null;
     this.cwdStudio = findStudio(cwd);
     this.current = this.cwdStudio;
@@ -110,13 +126,24 @@ export class StudioContext {
     return Boolean((this.studiosDir && inside(realOr(this.studiosDir), real)) || (this.cwdStudio && inside(realOr(this.cwdStudio), real)));
   }
 
+  /** Where `a` (a folder name, a studio's name, or a path inside the studios folder) would be a studio, or null. */
+  pathOf(a, list = this.studios()) {
+    const byName = list.find((s) => s.folder === a || s.name.toLowerCase() === a.toLowerCase() || slugify(s.name) === slugify(a));
+    return byName?.root ?? (isAbsolute(expandHome(a) ?? '') && (a.includes('/') || a.includes('\\') || a.startsWith('~')) ? expandHome(a) : this.studiosDir ? join(this.studiosDir, a) : null);
+  }
+
+  /** Whether `arg` names a studio that exists (as root() would find it). */
+  knows(arg) {
+    const path = this.pathOf(String(arg ?? '').trim());
+    return Boolean(path && existsSync(join(path, 'studio.json')));
+  }
+
   /** The studio a tool works in: `arg` (a folder name, a studio's name, or a path inside the studios folder). */
   root(arg, { need = true } = {}) {
     if (arg !== undefined && arg !== null && String(arg).trim()) {
       const a = String(arg).trim();
       const list = this.studios();
-      const byName = list.find((s) => s.folder === a || s.name.toLowerCase() === a.toLowerCase() || slugify(s.name) === slugify(a));
-      const path = byName?.root ?? (isAbsolute(expandHome(a) ?? '') && (a.includes('/') || a.includes('\\') || a.startsWith('~')) ? expandHome(a) : this.studiosDir ? join(this.studiosDir, a) : null);
+      const path = this.pathOf(a, list);
       if (!path || !existsSync(join(path, 'studio.json'))) throw new Error(`no studio "${a}"${list.length ? ` (studios here: ${list.map((s) => s.folder).join(', ')})` : ''}`);
       if (!this.allowed(path)) throw new Error(`${path} is outside the studios folder (${this.studiosDir ?? 'none is set'}); these tools only work in it`);
       this.current = realOr(path);
@@ -203,7 +230,7 @@ function checklist(ctx, root) {
   return steps.map((label, n) => ({ n, label, state: done[n] ? 'done' : n === now ? 'now' : 'todo' }));
 }
 
-async function setupCard(ctx, root, { fresh = false, made = null, install = null } = {}) {
+async function setupCard(ctx, root, { fresh = false, made = null, install = null, wanted = null } = {}) {
   const status = await statusOf(ctx, root, { fresh });
   const studios = ctx.studios().map(({ root: r, ...s }) => s);
   const current = root ? ctx.describe(root) : null;
@@ -212,6 +239,8 @@ async function setupCard(ctx, root, { fresh = false, made = null, install = null
   const steps = checklist(ctx, root);
   const data = {
     kind: 'setup', version: STUDIO_VERSION, studiosDir: ctx.studiosDir,
+    // The name of a studio that is not made yet (setup_status asked for it by name): the card is that new studio's.
+    wanted: current ? null : wanted,
     current: current ? { folder: current.folder, name: current.name, games: current.games, installed: current.installed, site: siteUrl(root) } : null,
     studios, checklist: steps,
     status: { rows: status.rows.map(({ parts, ...r }) => r), features: status.features, next: status.next, meanwhile: status.meanwhile, blocking: status.blocking },
@@ -220,16 +249,22 @@ async function setupCard(ctx, root, { fresh = false, made = null, install = null
     // homie.rocks). The card never asks for an address, and an agent never types one in for the person.
     updates: HOMIE_UPDATES,
   };
+  const others = studios.map((s) => s.name);
+  const first = (steps.find((s) => s.state === 'now')?.n ?? steps.length) <= 2;
   const text = [
-    current ? `Studio: ${current.name} (${root})${current.installed ? '' : job ? ' (installing its toolkit)' : ''}` : `No studio yet${ctx.studiosDir ? ` in ${ctx.studiosDir}` : ''}.`,
+    current ? `Studio: ${current.name} (${root})${current.installed ? '' : job ? ' (installing its toolkit)' : ''}`
+      : wanted ? `No studio called "${wanted}" yet${ctx.studiosDir ? ` in ${ctx.studiosDir}` : ''}${others.length ? ` (the studios here: ${others.join(', ')}; this checklist is the new studio's, not theirs)` : ''}: studio_scaffold makes it.`
+        : `No studio yet${ctx.studiosDir ? ` in ${ctx.studiosDir}` : ''}.`,
     '',
-    `New studio${current ? `: ${current.name}` : ''}`,
+    `New studio${current ? `: ${current.name}` : wanted ? `: ${wanted}` : ''}`,
     ...steps.map((s) => `  ${s.state === 'done' ? '✓' : s.state === 'now' ? '→' : ' '} ${s.n}. ${s.label}`),
     '',
     formatStatus(status),
     '',
     `Homie updates by email (optional): ${HOMIE_UPDATES} (the person signs up there themselves; never type an address in for them).`,
     'The card on screen shows this; it follows the install by itself.',
+    // The first minutes of a new studio in the Claude desktop app: what the person is told once (DESKTOP_APPROVALS).
+    ...(ctx.desktop && first ? ['', DESKTOP_APPROVALS] : []),
   ].join('\n');
   return ok(text, data);
 }
@@ -703,7 +738,7 @@ function guideTopics(ctx) {
   try { return readdirSync(ctx.skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory() && existsSync(join(ctx.skillsDir, d.name, 'SKILL.md'))).map((d) => d.name).sort(); } catch { return []; }
 }
 
-const DESKTOP_NOTE = 'In this app, where a guide says to run `npx --no-install homie-studio <command>`, call the tool of the same job (build, check, preview_run, studio_deploy, …) or studio_run with that command\'s words; where it says to edit a file, use file_read, file_edit and file_write; a guide\'s own script (music, sound, art, video) is the tool of that name.';
+const DESKTOP_NOTE = 'In this app, where a guide says to run `npx --no-install homie-studio <command>`, call the tool of the same job (build, check, preview_run, studio_deploy, …) or studio_run with that command\'s words; where it says to edit a file, use file_read, file_edit and file_write, in few, large calls: read a file once, then make every change it needs in ONE file_edit (its edits list takes many replacements) or one file_write of a new or short file, never a call per change (every call is a step the person waits on, and a turn has only so many); a guide\'s own script (music, sound, art, video) is the tool of that name.';
 
 /* ------------------------------------------------------------------ the tools */
 
@@ -717,10 +752,15 @@ export function toolDefs(ctx, avail = {}) {
   const tools = [
     {
       name: 'setup_status', title: 'Setup status',
-      description: 'Step 0 of a new studio, and any time the person asks what they need or whether they are set up: what this computer and their accounts have (Node, Cloudflare signed in and email verified, Chrome for the checks, ffmpeg, and the optional GitHub, ElevenLabs and fal), what each unlocks, and the exact fix; the studios in the studios folder; and the new-studio checklist with where they are on it. Read-only, a few seconds. Optional rows never block anything.',
-      inputSchema: { type: 'object', properties: { ...STUDIO_ARG, fresh: { type: 'boolean', description: 'Check again now instead of the last 20 s' } } },
+      description: 'Step 0 of a new studio, and any time the person asks what they need or whether they are set up: what this computer and their accounts have (Node, Cloudflare signed in and email verified, Chrome for the checks, ffmpeg, and the optional GitHub, ElevenLabs and fal), what each unlocks, and the exact fix; the studios in the studios folder; and the new-studio checklist with where they are on it. For a studio that is not made yet, pass its name as studio: the checklist is then the new studio\'s, never another studio\'s that happens to be in the folder. Read-only, a few seconds. Optional rows never block anything.',
+      inputSchema: { type: 'object', properties: { studio: str('Optional: which studio (its folder name or name), or the name of a new studio that is not made yet; else the one in use'), fresh: { type: 'boolean', description: 'Check again now instead of the last 20 s' } } },
       annotations: { title: 'Setup status', ...RO }, _meta: ui(UI.setup),
-      run: async (a) => setupCard(ctx, ctx.root(a.studio, { need: false }), { fresh: a.fresh === true }),
+      run: async (a) => {
+        // A name with no studio of it yet is the studio about to be made: its own checklist, from step 1.
+        const named = String(a.studio ?? '').trim().slice(0, 60);
+        if (named && !ctx.knows(named)) return setupCard(ctx, null, { fresh: a.fresh === true, wanted: named });
+        return setupCard(ctx, ctx.root(a.studio, { need: false }), { fresh: a.fresh === true });
+      },
     },
     {
       name: 'studio_scaffold', title: 'Make a studio',
@@ -840,7 +880,7 @@ export function toolDefs(ctx, avail = {}) {
         }
         const m = r.result?.models;
         const got = m ? ` Its models: ${m.fetched} from the starter library${m.missing.length ? `; ${m.missing.length} could not be fetched (${m.why ?? m.missing[0].why}), and it draws stand-ins for those` : ''}.` : '';
-        return ok(`games/${a.id} is ${a.name}, from the ${a.from ?? 'gem-rush'} starter (${(r.result?.files ?? []).length} files).${got}${install} Change it in games/${a.id}/src/main.ts (file_read, file_edit), then build and preview_run; check proves two browsers finish a round.`, { kind: 'game', ...r.result });
+        return ok(`games/${a.id} is ${a.name}, from the ${a.from ?? 'gem-rush'} starter (${(r.result?.files ?? []).length} files).${got}${install} Change it in games/${a.id}/src/main.ts: file_read it once (a long file in two or three reads), decide every change, and make them in ONE file_edit with an edits list (never a call per change: twenty single edits use up a turn before the game is checked); then build and preview_run; check proves two browsers finish a round.`, { kind: 'game', ...r.result });
       },
     },
     {
@@ -888,7 +928,7 @@ export function toolDefs(ctx, avail = {}) {
     },
     {
       name: 'game_plan', title: 'Plan a game (its Game Codex)',
-      description: 'Step 4: start the game\'s Game Codex (games/<id>/CODEX.md, every section) and get the plan interview to run with the person: two or three questions a message, each with options and your pick, about game type and genre, style, devices, players and rooms, art and film, music and sound, and scope. A game is planned before it is made: with no game <id> yet, this starts its folder with only the codex. Fill CODEX.md from their answers with file_edit, then game_codex shows it.',
+      description: 'Step 4: start the game\'s Game Codex (games/<id>/CODEX.md, every section) and get the plan interview to run with the person: two or three questions a message, each with options and your pick, about game type and genre, style, devices, players and rooms, art and film, music and sound, and scope. A game is planned before it is made: with no game <id> yet, this starts its folder with only the codex. Fill CODEX.md from their answers in one call (file_write of the whole file, or one file_edit with an edits list), then game_codex shows it.',
       inputSchema: { type: 'object', properties: { id: str('The game\'s id (lowercase, digits, hyphens)'), name: str('Its name, when the game is not made yet'), ...STUDIO_ARG }, required: ['id'] },
       annotations: { title: 'Plan a game', ...RW },
       run: async (a) => {
@@ -902,7 +942,7 @@ export function toolDefs(ctx, avail = {}) {
         const guide = ctx.skillsDir && existsSync(join(ctx.skillsDir, 'plan', 'references', 'INTERVIEW.md')) ? readFileSync(join(ctx.skillsDir, 'plan', 'references', 'INTERVIEW.md'), 'utf8') : null;
         return ok([
           made ? `Wrote games/${a.id}/CODEX.md (every section${made.planned ? '; the game is planned here before it is made' : ''}).` : `games/${a.id}/CODEX.md is there already: change it, never replace it.`,
-          'Now the interview: two or three questions a message, each with concrete options and your pick, so "yes" is an answer. Say back what you heard in one line before the next. Stop after three or four rounds; "just build it" means fill the rest with your own choices and list them under Open questions. Then fill CODEX.md (file_read it, file_edit each section) and show it with game_codex.',
+          'Now the interview: two or three questions a message, each with concrete options and your pick, so "yes" is an answer. Say back what you heard in one line before the next. Stop after three or four rounds; "just build it" means fill the rest with your own choices and list them under Open questions. Then fill CODEX.md in one call (file_read it once; then file_write the whole file, or one file_edit whose edits list has every section) and show it with game_codex.',
           ...(guide ? ['', guide] : []),
         ].join('\n'), { kind: 'plan', id: a.id, file: `games/${a.id}/CODEX.md`, created: Boolean(made) });
       },
@@ -1062,7 +1102,7 @@ export function toolDefs(ctx, avail = {}) {
           if (!r.ended) return stillRunning(r.job, 'The deploy plan');
           if (r.job.code !== 0) return fail(whyOf(r.job));
           const p = r.result;
-          return ok([`What going online does for ${p.studio}:`, ...p.cloudflare.map((x) => `  ${x.kind}${x.name ? ` ${x.name}` : ''}: ${x.what} [${x.state}]`), `Cost: ${p.cost}`, `Sign-in: ${p.login}`, `The directory stores: ${p.directory?.stores ?? ''}`].join('\n'), { kind: 'deploy-plan', ...p });
+          return ok([`What going online does for ${p.studio}:`, ...p.cloudflare.map((x) => `  ${x.kind}${x.name ? ` ${x.name}` : ''}: ${x.what} [${x.state}]`), `Cost: ${p.cost}`, `Sign-in: ${p.login}`, `The directory stores: ${p.directory?.stores ?? ''}`, 'The card on screen shows this plan (nothing is made yet): tell the person its gist in two or three lines, then go on.'].join('\n'), { kind: 'deploy-plan', ...p });
         }
         const studio = readStudio(root);
         return startRun(ctx, root, { kind: 'deploy', game: null, title: `${studio.name}: online`, steps: [{ label: 'deploy', args: ['deploy'] }] });
@@ -1294,14 +1334,18 @@ export function toolDefs(ctx, avail = {}) {
     },
     {
       name: 'file_edit', title: 'Edit a studio file',
-      description: 'Replace exact text in a studio file: old must match exactly once (spaces and line breaks too), or all: true for every match. Read the file first.',
-      inputSchema: { type: 'object', properties: { path: str('The file, relative to the studio'), old: str('The exact text to replace'), new: str('What replaces it'), all: { type: 'boolean' }, ...STUDIO_ARG }, required: ['path', 'old', 'new'] },
+      description: 'Replace exact text in a studio file: old must match exactly once (spaces and line breaks too), or all: true for every match. Read the file first. Several changes to one file go in ONE call: edits is a list of { old, new, all? } applied in order, all of them or none (a miss says which one, and the file is left as it was). Prefer one call with every change over a call per change.',
+      inputSchema: { type: 'object', properties: { path: str('The file, relative to the studio'), old: str('The exact text to replace (one change)'), new: str('What replaces it'), all: { type: 'boolean' }, edits: { type: 'array', description: 'Several changes to this file in one call, applied in order, all or none', items: { type: 'object', properties: { old: str('The exact text to replace'), new: str('What replaces it'), all: { type: 'boolean' } }, required: ['old', 'new'] } }, ...STUDIO_ARG }, required: ['path'] },
       annotations: { title: 'Edit a file', readOnlyHint: false, destructiveHint: true, openWorldHint: false },
       run: async (a) => {
         const root = ctx.root(a.studio);
-        const r = editStudioFile(root, a.path, a.old, a.new, { all: a.all === true });
+        const list = Array.isArray(a.edits) && a.edits.length ? a.edits : null;
+        if (!list && (a.old === undefined || a.new === undefined)) return fail('give old and new (one change), or edits: [{ "old": "…", "new": "…" }, …] for several changes to this file in one call');
+        const r = list
+          ? editStudioFile(root, a.path, null, null, { edits: [...(a.old !== undefined && a.new !== undefined ? [{ old: a.old, new: a.new, all: a.all === true }] : []), ...list] })
+          : editStudioFile(root, a.path, a.old, a.new, { all: a.all === true });
         ctx.note(root).changed = true;
-        return ok(`Changed ${r.rel} (${r.replaced} place${r.replaced === 1 ? '' : 's'}).`);
+        return ok(`Changed ${r.rel} (${r.replaced} place${r.replaced === 1 ? '' : 's'}${r.edits > 1 ? `, ${r.edits} edits in one call` : ''}).`);
       },
     },
     {
@@ -1333,7 +1377,7 @@ export function toolDefs(ctx, avail = {}) {
           return ok(readFileSync(f, 'utf8'));
         }
         const refs = (() => { try { return readdirSync(join(dir, 'references')); } catch { return []; } })();
-        return ok(`${DESKTOP_NOTE}\n\n${readFileSync(join(dir, 'SKILL.md'), 'utf8')}${refs.length ? `\n\nReferences (file): ${refs.join(', ')}` : ''}`);
+        return ok(`${DESKTOP_NOTE}${ctx.desktop ? `\n\n${DESKTOP_APPROVALS}` : ''}\n\n${readFileSync(join(dir, 'SKILL.md'), 'utf8')}${refs.length ? `\n\nReferences (file): ${refs.join(', ')}` : ''}`);
       },
     });
   }

package/lib/mcp.mjs

@@ -12,6 +12,9 @@
  *     --no-install never run npm install in a studio (tests, and a studio whose node_modules are linked by hand)
  *     --homie     the directory a new studio names (default https://homie.rocks)
  *
+ * HOMIE_STUDIO_EXTENSION=1 (the desktop extension's manifest sets it) says the server runs in the Claude desktop app,
+ * which asks the person before every tool call: only there, the model is told to say so once (DESKTOP_APPROVALS).
+ *
  * The transport is the MCP stdio transport: one JSON-RPC 2.0 message per line on stdin and stdout; logs go to
  * stderr. No SDK. MCP Apps cards (spec 2026-01-26, `text/html;profile=mcp-app`) are served as ui:// resources from
  * mcp/ui/ (real files, read as they are: a card's script is never built from a function's source), and every tool
@@ -20,7 +23,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { PACKAGE_ROOT } from './studio.mjs';
-import { StudioContext, UI, availability, toolDefs } from './mcp-tools.mjs';
+import { DESKTOP_APPROVALS, StudioContext, UI, availability, inDesktopApp, toolDefs } from './mcp-tools.mjs';
 import { stopAllJobs, toolPath } from './jobs.mjs';
 import { shrinkPictureData } from './pictures.mjs';
 import { STUDIO_VERSION } from './version.mjs';
@@ -31,12 +34,12 @@ export const MCP_APP_MIME = 'text/html;profile=mcp-app';
 export const INSTRUCTIONS = `Homie Studio, on this computer: make game studios and their multiplayer web games, music and videos, run them here, and put them online on the studio's own Cloudflare. (It is not the Homie house app: that app's own server, with its room and TV tools, is a different one.) These tools do the work in this chat; the person never types a command and never needs a terminal. A studio is a folder in the studios folder; the file tools (file_list, file_read, file_edit, file_write, file_search) work inside it.
 
 A new studio follows one checklist, in order and never ahead. Show it in your first reply and again, ticked, as each step ends:
-0. Setup status (setup_status): what this computer and their accounts have; optional rows never block.
+0. Setup status (setup_status; for a studio that is not made yet, pass its name as studio, so the checklist is the new studio's and never another's): what this computer and their accounts have; optional rows never block.
 1. The studio (studio_scaffold): it has NO game; its home page says "First game coming soon".
 2. See a working game (game_demo): a live game on Homie Arcade with its Play link, nothing copied in. Copy a starter in (game_make) only if they ask.
 3. One small change from one sentence of theirs: to the copied game, or to the studio's home (site/theme.json colours, a tagline in studio.json, a first post in posts/). Then build and preview_run, and they reload.
 4. Plan their game (game_plan): a short interview, two or three questions a message with options and your pick; then fill games/<id>/CODEX.md and show it (game_codex).
-5. Build it: build_open, then game_make under the planned id (the codex stays), file edits, build, preview_run, check. The card follows every build.
+5. Build it: build_open, then game_make under the planned id (the codex stays), file edits (few and large: one file_edit carries every change to a file in its edits list, never a call per change), build, preview_run, check. The card follows every build.
 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.
 
@@ -54,6 +57,9 @@ Telling Homie (homie_feedback): when the person is stuck, confused or frustrated
 
 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.`;
 
+/** What the server tells the model as it connects: the checklist, and in the Claude desktop app what it asks the person. */
+export const instructionsFor = ({ desktop = false } = {}) => (desktop ? `${INSTRUCTIONS}\n\n${DESKTOP_APPROVALS}` : INSTRUCTIONS);
+
 const CARD_FILES = { [UI.setup]: 'setup.js', [UI.build]: 'build.js', [UI.studio]: 'studio.js', [UI.codex]: 'codex.js', [UI.lab]: 'lab.js', [UI.style]: 'style.js', [UI.decision]: 'decision.js', [UI.cast]: 'cast.js', [UI.lineup]: 'lineup.js', [UI.rights]: 'rights.js', [UI.animation]: 'animation.js', [UI.feedback]: 'feedback.js' };
 const CARD_TITLES = { [UI.setup]: 'Studio setup', [UI.build]: 'Build progress', [UI.studio]: 'Studio', [UI.codex]: 'Game Codex', [UI.lab]: 'Game Lab', [UI.style]: 'Style board', [UI.decision]: 'Look decision', [UI.cast]: 'Cast', [UI.lineup]: 'Lineup', [UI.rights]: 'Rights', [UI.animation]: 'Clips', [UI.feedback]: 'Tell Homie' };
 const UI_DIR = join(PACKAGE_ROOT, 'mcp', 'ui');
@@ -136,11 +142,11 @@ function promptText(name, args = {}) {
 /**
  * The server. `input`/`output` are streams (stdin/stdout by default). Returns a promise that ends with the input.
  */
-export async function serveMcp({ studios = null, skills = null, cwd = process.cwd(), input = process.stdin, output = process.stdout, waitMs, directory = null, install = true, log = (line) => process.stderr.write(`[homie-studio mcp] ${line}\n`) } = {}) {
+export async function serveMcp({ studios = null, skills = null, cwd = process.cwd(), input = process.stdin, output = process.stdout, waitMs, directory = null, install = true, desktop = inDesktopApp(), log = (line) => process.stderr.write(`[homie-studio mcp] ${line}\n`) } = {}) {
   // A GUI app starts this with a short PATH: everything it runs sees the usual places Node, npm and ffmpeg live.
   process.env.PATH = toolPath();
   const skillsDir = skills ?? [join(PACKAGE_ROOT, '..', '..', 'plugins', 'homie', 'skills'), join(PACKAGE_ROOT, '..', 'skills')].find((d) => existsSync(join(d, 'studio-setup', 'SKILL.md'))) ?? null;
-  const ctx = new StudioContext({ studiosDir: studios, cwd, skillsDir, waitMs: waitMs ?? Number(process.env.HOMIE_MCP_WAIT_MS || 40_000), directory, install });
+  const ctx = new StudioContext({ studiosDir: studios, cwd, skillsDir, waitMs: waitMs ?? Number(process.env.HOMIE_MCP_WAIT_MS || 40_000), directory, install, desktop });
   let avail = availability();
   let names = '';
   const send = (message) => output.write(`${JSON.stringify(message)}\n`);
@@ -168,7 +174,7 @@ export async function serveMcp({ studios = null, skills = null, cwd = process.cw
             protocolVersion: PROTOCOLS.includes(asked) ? asked : PROTOCOLS[0],
             capabilities: { tools: { listChanged: true }, resources: { listChanged: false }, prompts: { listChanged: false } },
             serverInfo: { name: 'homie-studio', title: 'Homie Studio', version: STUDIO_VERSION },
-            instructions: INSTRUCTIONS,
+            instructions: instructionsFor({ desktop: ctx.desktop }),
           });
         }
         case 'ping': return reply({});

package/lib/scaffold.mjs

@@ -666,14 +666,14 @@ export { default, Table, Lobby } from '@homie-rocks/studio/worker';
   return files;
 }
 
-/** The template's first-run band on Home: one link that connects this studio to the Claude chat that set it up. */
-export const CONNECT_BAND = `<!-- A new studio from the Homie template. This band goes away once Claude works in the studio
+/** The template's first-run band on Home: one link that connects this studio to the chat that set it up. */
+export const CONNECT_BAND = `<!-- A new studio from the Homie template. This band goes away once a chat works in the studio
      (homie-studio setup attach removes it); delete it by hand any time. -->
 <div class="band-in" style="text-align:center">
   <p class="kicker">New studio</p>
   <h2>{{studio.name}} is live</h2>
-  <p>It runs on your own Cloudflare account. Connect it to the Claude chat that set it up, and Claude takes it from here.</p>
-  <p><a class="btn" href="/_studio/connect">Connect to Claude</a></p>
+  <p>It runs on your own Cloudflare account. Connect it to the chat that set it up, and that chat takes it from here.</p>
+  <p><a class="btn" href="/_studio/connect">Connect this chat</a></p>
 </div>
 `;
 
@@ -689,8 +689,9 @@ The button copies this studio into your GitHub, creates its Worker, database and
 deploys it with Workers Builds: every push to \`main\` goes live, and every other branch gets its own Preview.
 The site goes live at once with its own home page ("first game coming soon"); the games come next.
 
-Then open the site and tap **Connect to Claude**, or ask Claude in the Claude app to set up your studio with the
-Homie connector: it makes games, songs and videos here, in a pull request you merge with one tap.
+Then open the site and tap **Connect this chat**, or ask Claude, Codex or Grok (with the Homie connector,
+https://homie.rocks/mcp) to set up your studio: it makes games, songs and videos here, in a pull request you merge
+with one tap. Grok has no Cloudflare connector. Approving Cloudflare in the browser is still your step.
 
 \`AGENTS.md\` says how everything here works.
 `;

package/lib/setup.mjs

@@ -6,7 +6,7 @@
  *     and answers with the studio's live address once its site is connected (the card's Cloudflare step);
  *   - a copy of the public template (studio.json `template: true`) gets the name the person chose in the chat:
  *     studio.json, the Worker's STUDIO_NAME, and AGENTS.md and README.md while they are untouched; its first-run
- *     "Connect to Claude" band goes; studio.json takes the Worker and database names Cloudflare's form chose;
+ *     "Connect this chat" band goes; studio.json takes the Worker and database names Cloudflare's form chose;
  *   - the live address goes into .studio/local.json (git-ignored), so `check --url` and the card know it.
  *
  * It sends the repository's owner/name and the studio's name and slug, nothing else: no key, no path, no code.
@@ -16,6 +16,7 @@
 import { existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { configNames } from './cloudflare.mjs';
+import { studioClient } from './client.mjs';
 import { request } from './net.mjs';
 import { ENGINE_REPO, repoOf } from './repo.mjs';
 import { CONNECT_BAND, agentsMd, readme, slugify, templateReadme } from './scaffold.mjs';
@@ -24,8 +25,9 @@ import { STUDIO_VERSION } from './version.mjs';
 
 const SETUP_ID = /^hs_[a-f0-9]{32}$/;
 
-export async function setupAttach(root, id, { homie } = {}) {
-  if (!SETUP_ID.test(String(id ?? ''))) return { ok: false, command: 'setup attach', why: 'attach to the setup id the Claude app\'s setup card showed: hs_ and 32 hex digits' };
+export async function setupAttach(root, id, { homie, client } = {}) {
+  if (!SETUP_ID.test(String(id ?? ''))) return { ok: false, command: 'setup attach', why: 'attach to the setup id the setup card showed: hs_ and 32 hex digits' };
+  const who = studioClient(client);
   const studio = readStudio(root);
   const directory = String(homie || studio.homie?.directory || 'https://homie.rocks').replace(/\/+$/, '');
   const repo = repoOf(root);
@@ -34,7 +36,7 @@ export async function setupAttach(root, id, { homie } = {}) {
   }
   const sent = await request(`${directory}/api/studio/setup/${id}/attach`, {
     method: 'POST', headers: { 'content-type': 'application/json', 'user-agent': `homie-studio/${STUDIO_VERSION}` },
-    body: JSON.stringify({ repo, studio: { name: studio.name, slug: studio.slug, template: studio.template === true }, version: STUDIO_VERSION }),
+    body: JSON.stringify({ repo, studio: { name: studio.name, slug: studio.slug, template: studio.template === true }, version: STUDIO_VERSION, ...(who.id === 'chat' ? {} : { client: who.id }) }),
   });
   // What went wrong, as it is: the directory's own answer, or the connection's error. Never a guess at the network.
   if (!sent.ok) return { ok: false, command: 'setup attach', repo, ...(sent.status ? { status: sent.status } : {}), ...(sent.code ? { code: sent.code } : {}), ...(sent.needs ? { needs: sent.needs } : {}), why: sent.why };
@@ -72,10 +74,11 @@ export async function setupAttach(root, id, { homie } = {}) {
   if (now.github !== repo) { writeStudio(root, { ...now, github: repo }); if (!renamed.includes('studio.json')) renamed.push('studio.json'); }
   if (body.site) writeLocal(root, { url: body.site, connectedAt: new Date().toISOString() });
   return {
-    ok: true, command: 'setup attach', setup: id, repo, site: body.site ?? null, name: name ?? studio.name, renamed,
-    message: body.site ? `This repository is ${name ?? studio.name}, live at ${body.site}. The Claude app's card shows it.` : `This repository is ${name ?? studio.name}. Its site is not connected yet: ${body.connect ?? 'open the site and tap Connect to Claude'}.`,
+    ok: true, command: 'setup attach', setup: id, repo, client: who.id, site: body.site ?? null, name: name ?? studio.name, renamed,
+    message: body.site ? `This repository is ${name ?? studio.name}, live at ${body.site}. ${who.card[0].toUpperCase()}${who.card.slice(1)} shows it.` : `This repository is ${name ?? studio.name}. Its site is not connected yet: ${body.connect ?? `open the site and tap ${who.connect}`}.`,
     next: [
       ...(renamed.length ? ['commit the renamed files on a branch and open a pull request (merging it names the live site)'] : []),
+      ...(who.id === 'grok' ? ['a Grok Bot in this folder runs the checklist from here (there is no second session to start)'] : []),
       'npm install, then npx --no-install homie-studio progress attach <hb_…> when the chat opened a build',
     ],
   };

package/lib/template-history.json

@@ -1431,6 +1431,86 @@
      }
     }
    }
+  },
+  "0.30.0": {
+   "files": {
+    "CLAUDE.md": "ddf2b2a0376202f6",
+    "README.md": "684b3cca8001673c",
+    "HANDOFF.md": "ce7a8fd91c6bbee2",
+    "games/README.md": "5ad32fe80c61f117",
+    "music/README.md": "a3dc042dadd39df8",
+    "videos/README.md": "16babc3437d5545b",
+    "posts/README.md": "37841aae476bd540",
+    "site/README.md": "2928ca4f079ab76b",
+    "site/src/worker.mjs": "ca3f1630f2420ad3"
+   },
+   "sections": {
+    "AGENTS.md": {
+     "(intro)": "214aa46eb3a895d5",
+     "## Layout": "8baf49e4291e7e88",
+     "## Commands (all through the pinned CLI in node_modules)": "d80ec56e4b4fc4c6",
+     "## The site": "366ecce1a424837a",
+     "## Making games": "abf2f0d59341512d",
+     "## The Game Codex and progress": "0738ef719cef3a4c",
+     "## Art direction and models": "aaea65236db52126",
+     "## Running live games (the back office)": "4aa5f513a7cd2c3b",
+     "## Servers and AI seats": "98d08705087a33ec",
+     "## Selling things (the shop)": "b04b0a2b25f524f2",
+     "## Continuing a build from the Claude app": "0d68081e924ca419",
+     "## Rules": "7e8458adc1b81ece",
+     "## Telling Homie": "80b46fdd9e578db8",
+     "## Beta": "9d02638207a26e73"
+    }
+   },
+   "named": {
+    "Homie Arcade": {
+     "sections": {
+      "AGENTS.md": {
+       "## Commands (all through the pinned CLI in node_modules)": "b35df2c19cd4b534"
+      }
+     }
+    }
+   }
+  },
+  "0.30.1": {
+   "files": {
+    "CLAUDE.md": "ddf2b2a0376202f6",
+    "README.md": "684b3cca8001673c",
+    "HANDOFF.md": "ce7a8fd91c6bbee2",
+    "games/README.md": "5ad32fe80c61f117",
+    "music/README.md": "a3dc042dadd39df8",
+    "videos/README.md": "16babc3437d5545b",
+    "posts/README.md": "37841aae476bd540",
+    "site/README.md": "2928ca4f079ab76b",
+    "site/src/worker.mjs": "ca3f1630f2420ad3"
+   },
+   "sections": {
+    "AGENTS.md": {
+     "(intro)": "214aa46eb3a895d5",
+     "## Layout": "8baf49e4291e7e88",
+     "## Commands (all through the pinned CLI in node_modules)": "d80ec56e4b4fc4c6",
+     "## The site": "366ecce1a424837a",
+     "## Making games": "abf2f0d59341512d",
+     "## The Game Codex and progress": "0738ef719cef3a4c",
+     "## Art direction and models": "aaea65236db52126",
+     "## Running live games (the back office)": "4aa5f513a7cd2c3b",
+     "## Servers and AI seats": "98d08705087a33ec",
+     "## Selling things (the shop)": "b04b0a2b25f524f2",
+     "## Continuing a build from the Claude app": "0d68081e924ca419",
+     "## Rules": "7e8458adc1b81ece",
+     "## Telling Homie": "80b46fdd9e578db8",
+     "## Beta": "9d02638207a26e73"
+    }
+   },
+   "named": {
+    "Homie Arcade": {
+     "sections": {
+      "AGENTS.md": {
+       "## Commands (all through the pinned CLI in node_modules)": "b35df2c19cd4b534"
+      }
+     }
+    }
+   }
   }
  }
 }

package/mcp/ui/bridge.js

@@ -75,13 +75,26 @@ var Card = (function () {
     });
   }
   function textOf(r) { return (r && r.content && r.content[0] && r.content[0].text) || ''; }
+  // An answer's own words, for a card that has nothing of its own to draw from it: short enough to stay a card.
+  function words(r) {
+    var j = r && r.structuredContent;
+    if (j && j.kind === 'job' && j.label) return j.label + (j.state === 'running' ? ' is still running (' + (j.seconds || 0) + ' s so far). Ask again in a moment.' : ': ' + (j.state || 'done') + '.');
+    var t = textOf(r).trim(); return t.length > 1500 ? t.slice(0, 1500).replace(/\s+\S*$/, '') + ' …' : t;
+  }
   function render() {
     if (!spec) return;
-    var card;
+    var card = null;
     if (!S.data) {
-      card = el('main', 'card');
-      if (S.result && S.result.isError) add(card, top(spec.label, pill('Not done', 'bad')), el('p', 'note bad', textOf(S.result) || 'That did not work.'));
-      else add(card, top(spec.label, pill('Loading', 'live', true)), el('div', 'skel'), el('div', 'skel'));
+      // The tool answered, but not with this card's own data (a plan, a job still running, plain words). The card
+      // may draw that answer itself (spec.other); else it shows the answer's words. "Loading" is only for a tool
+      // that has not answered yet: an answered card never stays on the skeleton.
+      if (S.result && !S.result.isError && spec.other) { try { card = spec.other(S.result.structuredContent || {}, S.result) || null; } catch (e) { card = null; } }
+      if (!card) {
+        card = el('main', 'card');
+        if (S.result && S.result.isError) add(card, top(spec.label, pill('Not done', 'bad')), el('p', 'note bad', textOf(S.result) || 'That did not work.'));
+        else if (S.result) add(card, top(spec.label), el('p', 'note words', words(S.result) || 'Done.'));
+        else add(card, top(spec.label, pill('Loading', 'live', true)), el('div', 'skel'), el('div', 'skel'));
+      }
     } else {
       try { card = spec.render(S.data, S.result); } catch (e) { card = add(el('main', 'card'), top(spec.label), el('p', 'note bad', String(e && e.message || e))); }
       if (S.result && S.result.isError && S.data) card.appendChild(el('p', 'note bad', textOf(S.result)));
@@ -131,7 +144,10 @@ var Card = (function () {
     size: size, render: render, take: take, fullscreenButton: fullscreenButton, textOf: textOf,
     ctx: function () { return ctx; },
     state: S,
-    /** spec: { kind, label, render(data, result) -> element, poll(data) -> { tool, args, every } | null } */
+    /**
+     * spec: { kind, label, render(data, result) -> element, poll(data) -> { tool, args, every } | null,
+     *         other(structured, result) -> element | null: an answer of another kind this card draws itself }
+     */
     start: function (s) {
       spec = s;
       rpc('ui/initialize', {

package/mcp/ui/build.js

@@ -1,5 +1,6 @@
 /* The build card: one build's stages, each check going green, a picture and where to play it, money against the
- * budget, and Stop. It follows the build every 2 s while it runs and tells the model once when it ends. */
+ * budget, and Stop. It follows the build every 2 s while it runs and tells the model once when it ends. A deploy's
+ * plan (studio_deploy with plan: true) is drawn here too: what going online makes and costs, before it is made. */
 (function () {
   var C = Card;
   var ICON = { pass: '✓', done: '✓', fail: '✕', failed: '✕', running: '●', pending: '·', skip: '–', skipped: '–', stopped: '■' };
@@ -56,8 +57,28 @@
     }
     return card;
   }
+  // The deploy plan (studio_deploy with plan: true): what going online makes on the person's own Cloudflare and what
+  // it costs, before anything is made. It is the same tool as the deploy, so the app draws this card for it too.
+  function plan(p) {
+    var card = C.el('main', 'card');
+    C.add(card, C.top('Build', C.pill('Plan', '')), C.el('h1', '', (p.studio || 'The studio') + ': going online'),
+      C.el('p', 'sub', 'On your own Cloudflare account. Nothing has been made or changed yet.'));
+    var ul = C.el('ul', 'list');
+    (p.cloudflare || []).filter(function (x) { return x && x.name; }).forEach(function (x) {
+      var made = /^exists/.test(x.state || '');
+      ul.appendChild(C.add(C.el('li', made ? 'state-ok' : ''), C.el('span', 'cn', made ? '✓' : '+'),
+        C.add(C.el('div', 'cb'), C.el('b', '', x.kind + ' ' + x.name), C.el('span', '', x.state + (x.plan ? ' · ' + x.plan : '')))));
+    });
+    card.appendChild(ul);
+    if (p.cost) card.appendChild(C.el('p', 'note', p.cost));
+    card.appendChild(C.el('p', 'fine', 'Cloudflare asks you to approve once in your browser if this computer is not signed in (a free account works).'));
+    if (p.directory && p.directory.stores) card.appendChild(C.el('p', 'fine', 'The Homie directory stores ' + p.directory.stores));
+    if (p.never) card.appendChild(C.el('p', 'fine', p.never));
+    return card;
+  }
   C.start({
     kind: 'build', label: 'Build', fullscreen: true, render: render,
+    other: function (sc) { return sc && sc.kind === 'deploy-plan' ? plan(sc) : null; },
     poll: function (sc) { return sc.feed && sc.feed.state === 'running' ? { tool: 'build_progress', args: { build: sc.build }, every: 2000 } : null; },
   });
 })();

package/mcp/ui/card.css

@@ -20,6 +20,7 @@ h2{margin:16px 0 8px;font:600 13px/1.2 var(--f-sans);color:var(--c-fg2);text-tra
 .sub{margin:0 0 12px;color:var(--c-fg2);overflow-wrap:anywhere}
 .note{margin:10px 0 0;padding:10px 12px;border-radius:var(--r-md);background:var(--c-bg2);color:var(--c-fg2)}
 .note.bad{background:var(--c-badbg);color:var(--c-bad)}.note.ok{background:var(--c-okbg);color:var(--c-ok);font-weight:600}
+.note.words{margin-top:0;white-space:pre-wrap;overflow-wrap:anywhere}
 .fine{margin:10px 0 0;font-size:12px;color:var(--c-fg3)}
 .pill{display:inline-flex;align-items:center;gap:6px;padding:4px 10px;border-radius:var(--r-full);font:600 12px/1.2 var(--f-sans);background:var(--c-bg2);color:var(--c-fg2);white-space:nowrap}
 .pill.ok{background:var(--c-okbg);color:var(--c-ok)}.pill.bad{background:var(--c-badbg);color:var(--c-bad)}.pill.warn{background:var(--c-warnbg);color:var(--c-warn)}

package/mcp/ui/setup.js

@@ -21,8 +21,8 @@
     var install = sc.install;
     var head = install && install.state === 'running' ? C.pill('Installing · ' + install.seconds + ' s', 'live', true)
       : cur ? C.pill(cur.games.length ? cur.games.length + (cur.games.length === 1 ? ' game' : ' games') : 'No game yet', cur.games.length ? 'ok' : '') : C.pill('New studio', '');
-    C.add(card, C.top('Studio setup', head), C.el('h1', '', cur ? cur.name : 'Set up a studio'),
-      C.el('p', 'sub', cur ? (cur.games.length ? 'On this computer, in ' + cur.folder : 'On this computer, in ' + cur.folder + '. Its home page says "First game coming soon".') : 'Studios live in ' + (sc.studiosDir || 'the folder set in the Homie extension') + '.'));
+    C.add(card, C.top('Studio setup', head), C.el('h1', '', cur ? cur.name : sc.wanted || 'Set up a studio'),
+      C.el('p', 'sub', cur ? (cur.games.length ? 'On this computer, in ' + cur.folder : 'On this computer, in ' + cur.folder + '. Its home page says "First game coming soon".') : (sc.wanted ? 'Not made yet. ' : '') + 'Studios live in ' + (sc.studiosDir || 'the folder set in the Homie extension') + '.'));
     var ol = C.el('ol', 'list');
     (sc.checklist || []).forEach(function (s) { ol.appendChild(step(s)); });
     card.appendChild(ol);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homie-rocks/studio",
-  "version": "0.29.0",
+  "version": "0.30.1",
   "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, big songs and videos in the studio's own R2 once it has storage (uploaded, checked by SHA-256, served at the same addresses), deploy, and the homie.rocks directory.",
   "type": "module",
   "license": "Apache-2.0",

package/worker/index.mjs

@@ -589,7 +589,7 @@ async function route(request, env, ctx) {
   const getAll = () => (catP ??= catalogue(env, url.origin).then((cat) => named(cat, env)));
   const getCat = () => (pubP ??= Promise.all([getAll(), settingsOf(env)]).then(([cat, settings]) => publicCatalogue(cat, settings, env)));
 
-  // "Connect to Claude" (the template's first-run band): the directory's setup page, for this site's address.
+  // "Connect this chat" (the template's first-run band): the directory's setup page, for this site's address.
   if (path === '/_studio/connect' && read) {
     const directory = directoryOf(await getCat());
     if (!directory || env.HOMIE_PREVIEW === '1') return json({ ok: false, error: 'no-directory', message: 'This studio is not connected to a directory.' }, 404);

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.29.0';
+export const STUDIO_VERSION_TAG = '0.30.1';