@homie-rocks/studio 0.30.0 → 0.30.2

package/CHANGELOG.md

@@ -17,9 +17,71 @@ 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.2] - 2026-10-04
+
+**Plugin 0.31.2** · [#48](https://github.com/homie-rocks/homie/pull/48)
+
+Fixes from first runs in Codex and Grok: a missing connector no longer stops a new studio, you are told when Homie's holds are off (in Grok they are), Grok has an install command, and a one-sentence studio gives you a Play link before it polishes.
+
+### Added
+
+- `homie-studio setup status --client codex` (or `--client grok`) has a row, **Homie's holds**: on when the plugin's hooks ran in that app in the last ten minutes, off otherwise, with how to turn them on. Codex runs no plugin's hooks until you trust them in `/hooks`, and says nothing when it skips them, so a session where nothing was held looked the same as one where everything was. The hooks now leave a small dated mark each time they run (in `.cache/homie-studio/holds/` of your home folder: the app, the time and which hook, nothing else), and the status reads it. When the holds are off, your AI says so in its first reply and asks you itself before a deploy, a Cloudflare change, a paid call or a model download. When they are on, nothing changes. In Grok the row is off (see Fixed).
+- The setup status says when another MCP server has taken the connector's name. The plugin's connector is the MCP server `homie`. If your Codex or Grok configuration already has a server of that name, that one keeps the name and the plugin's tools do not load. The connector row says so and gives the command that adds Homie's connector under its own name (`codex mcp add homie-rocks --url https://homie.rocks/mcp`), which your AI runs only with your yes. It reads only whether your entry is an address or a command, never the command itself.
+- Grok Build has an install command in the README: `grok plugin install homie-rocks/homie#plugins/homie` (checked on Grok Build 1.0.41). Grok asks whether to trust the plugin, and loads its skills, its MCP server and its hooks once you do.
+- A note you send to Homie from Grok says it came from Grok, not from "another app".
+
+### Changed
+
+- **A missing connector no longer stops a new studio.** In Codex, "set up a game studio called X and make a multiplayer game" stopped after a minute with nothing made: the `studio-setup` skill said to stop when the Homie connector was not connected. A session that can run commands does not need it. Your AI now says in one line that the connector is not connected and what it would add, and makes the studio with the toolkit's own command (`npx -y @homie-rocks/studio@latest new <folder> --name "<Name>"`). It stops only when it has neither the connector nor a way to run a command, and then it says how to add the connector in that app. The setup status no longer calls the connector required.
+- Other studios in the same folder are left alone. A new studio's `AGENTS.md` and the `studio-setup` and `game` skills say that a studio in a folder beside yours is somebody else's work: your AI does not read it or copy from it unless you ask. In a test, an AI read the game next door as a model for its own.
+- **A Play link first.** Asked for everything at once, your AI now tells you the moment two browsers finish a round, with the link to play, and only then goes on to sound, art, the playtest's fixes and the landing page, saying what it is doing. The same sentence took 55 to 80 minutes to its first word in Claude Code, Codex and Grok, polishing all the way.
+- Going online never lists a studio. The `studio-setup` and `publish` skills now say that listing in the homie.rocks directory is its own step, public, and yours to ask for: your AI lists a studio when you asked for it or said yes to its offer, never as part of a deploy.
+- The skills no longer suggest a status line, a pane or a card in Codex or Grok, where Homie draws none.
+- The README says what Claude Code means by "9 userConfig options not yet set" after an install: the Homie mod's nine switches, all optional and already at their defaults. Nothing is left to do.
+- Shorter ways in, in the README. Claude Code: one line inside a session, `/plugin install homie --marketplace homie-rocks/homie` (2.1.275 or later). The Claude app: a link that opens "Add custom connector" with Homie filled in, so nobody types the address.
+
+### Fixed
+
+- **Homie's holds do not run in Grok, and Homie no longer says they do.** 0.30.0 said Grok held the same calls as Claude Code and Codex. In a real run Grok deployed without asking. Grok Build 1.0.41 runs no plugin's hooks: its own log shows none registered in headless and agent sessions, for every installed plugin that ships hooks and for a test plugin holding nothing but a standard hooks file, so it is not Homie's layout. The README, the plugin's description and the skills now say that nothing is held in Grok and no secret is taken out of what Grok reads; the setup status says "Homie's holds: off"; and the `studio-setup` skill tells Grok to ask you before a deploy, a Cloudflare change, a paid call, a model download or an edit to a protected file. The hooks still ship, and the status turns on by itself with a Grok that runs them.
+- "See a working game" where commands have no network (Codex runs them that way by default). `homie-studio demo` answered with the arcade's standing first pick, and your AI passed on that "the lookup couldn't reach the arcade". It now gives you the link as the live game it is: your browser opens it, not the session. The answer says `reached: false` and no longer blames the arcade for a network the session did not have.
+- The setup status showed "List games in the homie.rocks directory" as not ready without the connector. Listing needs the directory, which `homie-studio publish` reaches by itself.
+
+### Upgrade notes
+
+- Codex: if you have not yet, open `/hooks` and trust Homie's three hooks. `setup status --client codex` says whether they are on.
+- Grok: nothing to install or switch on. Nothing holds a deploy or a paid call in Grok yet, so read what Grok is about to do when it asks; if it does not ask, tell it to.
+- An existing studio: `upgrade --apply` brings the new lines into the Rules section of its `AGENTS.md` when you have not changed that section. Nothing else in a studio changes.
+
+## [0.30.1] - 2026-10-04
+
+**Plugin 0.31.1** · [#47](https://github.com/homie-rocks/homie/pull/47) · [release-2026-10-04-studio-0.30.1](https://github.com/homie-rocks/homie/releases/tag/release-2026-10-04-studio-0.30.1)
+
+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)
+**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.
 

package/README.md

@@ -6,7 +6,7 @@ contract (every browser renders, strangers meet in public rooms, bots fill seats
 restart), and a site Worker with Table/Lobby Durable Objects and D1 that the studio deploys
 to its own Cloudflare account with Wrangler. The homie.rocks directory lists the games.
 
-Most people never run this by hand: the Homie plugin for Claude Code and Codex does,
+Most people never run this by hand: the Homie plugin for Claude Code, Codex and Grok does,
 and the person approves Cloudflare once in their browser.
 
 ```sh
@@ -442,6 +442,23 @@ one token out: about 0.1 of the 10,000 free neurons a day; `lib/brain-probe.mjs`
 Workers Paid (error 5035) or retired (5007) is named, with what to do: pick another model, or, the person's money,
 Workers Paid. A spent daily allowance (3036) is said as that, not as a broken model.
 
+A missing connector never blocks (0.30.2): a session that can run commands makes, deploys and lists a studio with
+this toolkit alone (`new`, `deploy`, `publish`), and the connector row says so. With `--client codex` or
+`--client grok` (in Codex the toolkit also reads the app from its environment) two things more:
+
+- **The connector's name.** The Homie plugin's connector is the MCP server `homie`. When the app's own
+  configuration (`config.toml` in its home folder, or `.codex/` or `.grok/` in this folder) already has another
+  server of that name, the plugin's does not load. The row says so and gives the command that adds Homie's connector
+  under its own name (`codex mcp add homie-rocks --url https://homie.rocks/mcp`). It reads only whether that entry is
+  an address or a command; the command itself is never read out.
+- **Homie's holds**: whether the plugin's hooks ran in this app in the last ten minutes, from the dated mark
+  they leave in `.cache/homie-studio/holds/` of the home folder. Off means nothing is held: Codex runs no plugin's hooks
+  until the person trusts them in `/hooks`, and the row says so; Grok Build 1.0.41 runs no plugin's hooks at all, so
+  there the row is off until a Grok that does.
+
+`homie-studio demo` answers without a network too (0.30.2): where it cannot reach the arcade it names the arcade's
+standing first pick, with `reached: false`.
+
 ## The Game Codex
 
 `games/<id>/CODEX.md` is a game's plan: Markdown with a small frontmatter for its look (palette, fonts, a

package/bin/homie-studio.mjs

@@ -187,11 +187,15 @@
  *                                          pages; the account id goes into studio.json, the token stays in Projects'
  *                                          vault and its git-ignored .env, and Wrangler runs with it here. The usual
  *                                          way, npx wrangler login, stays the default. lib/projects.mjs)
- *   homie-studio setup status [--connector yes|no]   (also: homie-studio doctor)
+ *   homie-studio setup status [--connector yes|no] [--client claude|codex|grok]   (also: homie-studio doctor)
  *                                         what this computer and the person's accounts have for a studio: Node, the Homie
  *                                         connector, Cloudflare (signed in, email verified), Chrome, ffmpeg, GitHub,
  *                                         ElevenLabs, fal; green, missing or "do this now", what each unlocks and its
  *                                         exact fix. Read-only and safe any time, inside a studio or before one exists.
+ *                                         A missing connector never blocks: a session with a shell makes a studio with
+ *                                         `new`. In Codex and Grok Build (--client, or the app's own environment) it
+ *                                         also says whether Homie's holds are on (the plugin's hooks ran just now), and
+ *                                         when another MCP server named homie has taken the connector's name there.
  *
  *   homie-studio codex new <id> [--name "<Name>"]
  *                                         games/<id>/CODEX.md: the Game Codex, every section, in the game's colours (a game
@@ -692,7 +696,7 @@ async function main() {
   if (cmd === 'port' && sub === 'plan') return planPort(positional[2] ?? '.');
   if (cmd === 'chrome' && sub === 'install') return installChrome({ log, fresh: flags.has('fresh') });
   if (cmd === 'chrome') { const chrome = findChrome(); return chrome ? { ok: true, command: 'chrome', chrome, args: chromeArgs() } : { ok: false, command: 'chrome', why: noChrome() }; }
-  if ((cmd === 'setup' && sub === 'status') || cmd === 'doctor') return setupStatus({ connector: flags.get('connector') ?? null, homie: flags.get('homie') ?? null });
+  if ((cmd === 'setup' && sub === 'status') || cmd === 'doctor') return setupStatus({ connector: flags.get('connector') ?? null, homie: flags.get('homie') ?? null, client: flags.get('client') ?? null });
   if (cmd === 'statusline' && !flags.has('install') && !flags.has('remove')) {
     const line = statusLine({ columns: Number(process.env.COLUMNS) || 100, color: !process.env.NO_COLOR && !asJson && process.stdout.isTTY });
     if (asJson) return { ok: true, command: 'statusline', line };

package/lib/demo.mjs

@@ -8,8 +8,12 @@
  * studio only when the person asks for one: `homie-studio game new <id> --from gem-rush`.
  *
  * It reads the arcade's own public manifest (/.well-known/homie-studio.json) and its live rooms (/api/rooms), so the
- * links are the ones live right now; when the arcade does not answer, it names its usual first pick. Read-only.
+ * links are the ones live right now. When this session cannot reach the arcade (a sandbox with no network, as Codex
+ * runs commands by default; a proxy; the arcade slow), it still answers, with the arcade's standing first pick
+ * (DEMO_FALLBACK, built in) and `reached: false`: the person's own browser opens that link, not this session, so it
+ * is still a live game to try. Read-only.
  */
+import { whyFailed } from './net.mjs';
 import { STUDIO_VERSION } from './version.mjs';
 
 export const DEMO_STUDIO = 'https://arcade.homie.rocks';
@@ -34,13 +38,17 @@ async function getJson(fetchFn, url, ms) {
 
 export async function demoGames({ fetchFn = globalThis.fetch, studio = DEMO_STUDIO, timeoutMs = 6000 } = {}) {
   const site = String(studio).replace(/\/+$/, '');
-  let manifest = null; let rooms = null; let why = null;
+  let manifest = null; let rooms = null; let why = null; let refused = false;
   try {
     [manifest, rooms] = await Promise.all([
       getJson(fetchFn, `${site}/.well-known/homie-studio.json`, timeoutMs),
       getJson(fetchFn, `${site}/api/rooms`, timeoutMs).catch(() => null),
     ]);
-  } catch (error) { why = error?.message ?? String(error); }
+  } catch (error) {
+    // The arcade answered with an error, or this session never got to it (no network here, a proxy, a timeout).
+    refused = /answered \d{3}$/.test(String(error?.message));
+    why = refused ? error.message : whyFailed(error, site).why;
+  }
   const live = new Map();
   for (const r of Array.isArray(rooms?.rooms) ? rooms.rooms : []) {
     const id = text(r?.game, 40);
@@ -63,7 +71,11 @@ export async function demoGames({ fetchFn = globalThis.fetch, studio = DEMO_STUD
     ok: true, command: 'demo',
     studio: { name: text(manifest?.name, 60) || 'Homie Arcade', site },
     pick, games: games.length ? games : [pick],
-    ...(why ? { note: `the arcade did not answer just now (${why}); this is its usual first pick` } : {}),
+    // Whether this session read the arcade just now. Not reached: the pick is the built-in one, and its link is as good.
+    reached: !why,
+    ...(why ? { note: refused
+      ? `the arcade did not give its list just now (${why}), so this is its standing first pick`
+      : `this session could not reach the arcade just now (${why}), so this is its standing first pick; the Play link opens in the person's own browser all the same` } : {}),
     how: HOW, copy: COPY,
   };
 }

package/lib/doctor.mjs

@@ -4,8 +4,16 @@
  * unlocks, and the exact fix: one command the AI runs, or one page the person taps.
  *
  *   Node.js            required    the toolkit runs on it
- *   Homie connector    required    the directory, cards and the pinned toolkit's address (the AI says whether its
- *                                  Homie tools are there: --connector yes|no)
+ *   Homie connector    recommended the directory's search and remixes, the cards and notes to Homie (the AI says
+ *                                  whether its Homie tools are there: --connector yes|no). A session with a shell makes,
+ *                                  deploys and lists a studio without it, so a missing connector never blocks. When
+ *                                  the tools are missing and the app in use (Codex, Grok) has another MCP server named
+ *                                  homie in its own config, the row says so: that name is the plugin's connector's
+ *   Homie's holds      in Codex and Grok Build only: whether the plugin's hooks ran just now (they leave a dated
+ *                                  mark, hooks/codex.mjs), so a session where nothing is held says so, and how to turn
+ *                                  them on (Codex: trust them in /hooks; Grok Build 1.0.41 runs no plugin's hooks, so
+ *                                  there the row is off until a Grok that runs them). The app is the one the AI names
+ *                                  (--client codex|grok) or its environment shows
  *   Cloudflare         to go online: signed in, and the account's email verified (Cloudflare checks that at the
  *                                  first deploy; a deploy that went through proves it)
  *   Workers AI         for AI guides  only when a server's guides think with Workers AI: the model they use
@@ -25,13 +33,16 @@
  * It is safe at any time, inside a studio or before one exists: it only reads (local files, `--version` of a few
  * tools, `wrangler whoami`, `gh auth status`, `elevenlabs auth status`, one GET to the directory and, when a fal key
  * is set, fal's free pricing API; when a server's AI guides use Workers AI, one read of the live database and one
- * one-word call to the model), never changes anything, and never prints a key, a token or an account's name or id.
+ * one-word call to the model; in Codex or Grok, the `[mcp_servers.homie]` table of that app's config.toml, of which
+ * it keeps only whether it is an address or a command, and the hooks' mark in this user's cache), never changes
+ * anything, and never prints a key, a token, a command line or an account's name or id.
  * Every check has a time limit, so it answers in seconds even with no network.
  */
 import { spawn } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { workersAiRow } from './brain-probe.mjs';
+import { studioClient } from './client.mjs';
 import { detectLocalAi } from './local-ai.mjs';
 import { findChrome } from './chrome.mjs';
 import { whyFailed } from './net.mjs';
@@ -72,14 +83,95 @@ async function reach(url, fetchFn, ms = 5000) {
   }
 }
 
+/** The apps whose own configuration this status reads: where it is, and that app's own words for a fix. */
+const APPS = {
+  codex: { name: 'Codex', home: (env, home) => env.CODEX_HOME || (home && join(home, '.codex')) || null, project: '.codex', add: (name, url) => `codex mcp add ${name} --url ${url}` },
+  grok: { name: 'Grok', home: (env, home) => env.GROK_HOME || (home && join(home, '.grok')) || null, project: '.grok', add: (name, url) => `grok mcp add ${name} ${url}` },
+};
+/** The name Homie's connector takes when another MCP server already has `homie`. No underscore: Grok's hooks match on it. */
+export const CONNECTOR_NAME = 'homie-rocks';
+
+/**
+ * Which app this session runs in, for the rows that differ by app: the one the AI named (`--client`, or HOMIE_CLIENT),
+ * else what the app's own environment shows (Claude Code and Codex set variables of their own on the commands they
+ * run). Null when neither says: never a guess.
+ */
+export function sessionApp(client, env = process.env) {
+  const said = studioClient(client, env).id;
+  if (said !== 'chat') return said;
+  if (env.CLAUDECODE === '1') return 'claude';
+  if (env.CODEX_THREAD_ID || env.CODEX_SANDBOX || env.CODEX_SANDBOX_NETWORK_DISABLED || env.CODEX_CI) return 'codex';
+  return null;
+}
+
+/**
+ * Another MCP server under the name the Homie plugin's connector uses (`homie`), in the configuration of the app in
+ * use: its config.toml in the app's home folder, or the one in this folder (`.codex/`, `.grok/`). The person's own
+ * entry wins over a plugin's of the same name, so the plugin's tools never load. It reads only the
+ * `[mcp_servers.homie]` table's `url` and `command` keys, and returns only what kind of server it is and where it
+ * was found, never the command, its arguments, its environment or a header. Null when there is none, or it is
+ * Homie's own address.
+ */
+export function connectorClash({ app, env = process.env, cwd = process.cwd(), root = null, directory = 'https://homie.rocks' } = {}) {
+  const a = APPS[app];
+  if (!a) return null;
+  const home = env.HOME || env.USERPROFILE || '';
+  const ours = new Set(['https://homie.rocks/mcp', `${String(directory).replace(/\/+$/, '')}/mcp`]);
+  const places = [
+    ...[...new Set([root, cwd].filter(Boolean))].map((dir) => ({ file: join(dir, a.project, 'config.toml'), where: `this folder's ${a.project}/config.toml` })),
+    { file: a.home(env, home) ? join(a.home(env, home), 'config.toml') : null, where: `config.toml in ${a.name}'s home folder` },
+  ];
+  for (const { file, where } of places) {
+    let text;
+    try { if (!file || !existsSync(file)) continue; text = readFileSync(file, 'utf8'); } catch { continue; }
+    if (text.length > 16 * 1024 * 1024) continue;
+    const lines = text.split(/\r?\n/);
+    const at = lines.findIndex((l) => /^\s*\[\s*mcp_servers\s*\.\s*(?:"homie"|'homie'|homie)\s*\]\s*(?:#.*)?$/.test(l));
+    if (at < 0) continue;
+    let url = null; let command = false;
+    for (let i = at + 1; i < lines.length && !/^\s*\[/.test(lines[i]); i += 1) {
+      const m = /^\s*(url|command)\s*=\s*(.*?)\s*$/.exec(lines[i]);
+      if (!m) continue;
+      if (m[1] === 'command') command = true;
+      else url = (/^(["'])(.*?)\1/.exec(m[2])?.[2] ?? m[2]).replace(/\/+$/, '');
+    }
+    if (url && !command && ours.has(url)) return null;
+    return { app, name: a.name, where, kind: command ? 'a local command' : url ? 'another address' : 'another server' };
+  }
+  return null;
+}
+
+/** How long a mark of Homie's hooks counts as "ran just now": they stamp it at every message and every tool call. */
+export const HOLDS_FRESH_MS = 10 * 60_000;
+
+/**
+ * The mark Homie's hooks leave each time they run in Codex or Grok Build (the plugin's hooks/codex.mjs `mark`): a
+ * small dated file in this user's cache, <app>.json, { v, app, at, event }. { at, event, ageMs } or null. HOMIE_HOLDS_MARKS
+ * names another folder (the tests use it).
+ */
+export function holdsMark(app, { env = process.env, now = Date.now() } = {}) {
+  const home = env.HOME || env.USERPROFILE || '';
+  const dir = env.HOMIE_HOLDS_MARKS || (home && join(home, '.cache', 'homie-studio', 'holds'));
+  if (!dir || !/^[a-z]+$/.test(String(app ?? ''))) return null;
+  try {
+    const m = JSON.parse(readFileSync(join(dir, `${app}.json`), 'utf8'));
+    const at = Number(m?.at);
+    if (!Number.isFinite(at) || at <= 0) return null;
+    return { at, event: typeof m.event === 'string' ? m.event.slice(0, 20) : null, ageMs: Math.max(0, now - at) };
+  } catch { return null; }
+}
+
+const ago = (ms) => (ms < 90_000 ? `${Math.max(1, Math.round(ms / 1000))} s` : ms < 90 * 60_000 ? `${Math.round(ms / 60_000)} min` : ms < 36 * 3_600_000 ? `${Math.round(ms / 3_600_000)} h` : `${Math.round(ms / 86_400_000)} days`);
+
 /**
  * The checklist. `connector`: what the AI knows about its own tools ('yes' when the Homie MCP tools such as
- * studio_scaffold are in its tool list, 'no' when they are not, null when unsaid). `exec` and `fetchFn` are
+ * studio_scaffold are in its tool list, 'no' when they are not, null when unsaid). `client`: the app the AI says it
+ * is ('claude', 'codex', 'grok'; sessionApp reads the environment when it is unsaid). `exec`, `fetchFn` and `nowMs` are
  * replaceable for tests.
  */
 export async function setupStatus({
-  cwd = process.cwd(), env = process.env, platform = process.platform, connector = null, homie = null,
-  exec = defaultExec, fetchFn = globalThis.fetch, chrome = findChrome, node = process.versions.node,
+  cwd = process.cwd(), env = process.env, platform = process.platform, connector = null, homie = null, client = null,
+  exec = defaultExec, fetchFn = globalThis.fetch, chrome = findChrome, node = process.versions.node, nowMs = Date.now(),
 } = {}) {
   const root = findStudio(cwd);
   let studio = null;
@@ -148,24 +240,58 @@ export async function setupStatus({
     })(),
   ]);
 
-  // The Homie connector.
+  // The Homie connector. A session with a shell makes, deploys and lists a studio without it, so it never blocks.
+  const app = sessionApp(client, env);
   {
+    const host = new URL(directory).host;
     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. 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.',
+      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 (codex plugin marketplace add homie-rocks/homie, then codex plugin add homie@homie) and start a new session. Grok Build: grok plugin install homie-rocks/homie#plugins/homie (Grok asks whether to trust it), then a new session. The Claude app, or Grok chat: 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. Meanwhile a session with a shell goes on without it: ${cli} ${root ? '<command>' : 'new <folder> --name "<Name>"'} makes ${root ? 'everything in the studio' : 'the studio'}.`,
     };
+    // Another MCP server already called `homie` in this app's own config: the plugin's connector cannot load under it.
+    const clash = said !== 'yes' ? connectorClash({ app, env, cwd, root, directory }) : null;
+    const fixClash = clash ? {
+      who: 'ai', run: APPS[clash.app].add(CONNECTOR_NAME, `${directory}/mcp`),
+      say: `Another MCP server named homie is set up in ${clash.name} (${clash.where}). The Homie plugin's connector has the same name, and an app loads one server under a name, so the plugin's tools are missing while that one is there. This adds Homie's connector under its own name, ${CONNECTOR_NAME}, and leaves the other server as it is; you approve it, then start a new session. Until then your AI goes on with the studio's own commands.`,
+    } : null;
     let state; let detail;
-    if (net.blocked) { state = 'act'; detail = `the network proxy of this machine refused ${new URL(directory).host}`; }
+    if (net.blocked) { state = 'act'; detail = `the network proxy of this machine refused ${host}`; }
     else if (said === 'yes') { state = 'ok'; detail = net.ok ? 'the Homie tools are here, and the directory answers' : `the Homie tools are here; this computer's request to the directory failed just now: ${net.why}`; }
-    else if (said === 'no') { state = 'act'; detail = 'the Homie tools are not in this session'; }
+    else if (clash) { state = 'act'; detail = `${said === 'no' ? 'the Homie tools are not in this session' : 'your AI knows whether its Homie tools (studio_scaffold) are here'}; another MCP server named homie (${clash.kind}) is set up in ${clash.name}, in ${clash.where}, and it takes the name the Homie plugin's connector uses`; }
+    else if (said === 'no') { state = 'act'; detail = 'the Homie tools are not in this session; a studio is still made, checked, deployed and listed with the studio\'s own commands'; }
     // The directory not answering this computer says nothing about the connector: say what failed, as it is.
-    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}`; }
+    else { state = 'unknown'; detail = net.ok ? `${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 setup cards',
+      id: 'connector', label: 'Homie connector', need: 'recommended', state, detail,
+      unlocks: 'searching the homie.rocks directory and remixing a game from it, the cards where your app draws them, and notes to Homie; a session with a shell makes, deploys and lists a studio without it',
       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,
+        ? { who: 'person', say: `In claude.ai/code, open this environment's settings, set Network access to Custom, add ${host} (keep the default package managers), and start a new session.` }
+        : fixClash ?? (said === 'no' || net.ok ? fixConnector : null),
+      ...(clash && !net.blocked ? { clash: { app: clash.app, server: 'homie', kind: clash.kind, where: clash.where, as: CONNECTOR_NAME } } : {}),
+    });
+  }
+
+  // Homie's holds, in Codex and Grok Build: Codex runs the plugin's hooks only once the person has trusted them, Grok
+  // Build 1.0.41 was seen to run no plugin's hooks at all, and neither app says so. The hooks leave a dated mark at
+  // every message and tool call; a fresh one means they are on. Off in Grok is Grok's doing, so it is said as that.
+  if (app === 'codex' || app === 'grok') {
+    const name = APPS[app].name;
+    const seen = holdsMark(app, { env, now: nowMs });
+    const on = Boolean(seen && seen.ageMs <= HOLDS_FRESH_MS);
+    rows.push({
+      // Off in Codex is the person's to fix now (trust the hooks); off in Grok is nothing they can fix.
+      id: 'holds', label: 'Homie\'s holds', need: 'recommended', state: on ? 'ok' : app === 'codex' ? 'act' : 'optional', on, app,
+      detail: on ? `on: Homie's hooks ran in ${name} ${ago(seen.ageMs)} ago`
+        : seen ? `off: Homie's hooks last ran in ${name} ${ago(seen.ageMs)} ago, and not for this session's calls`
+          : app === 'grok' ? 'off: Grok Build runs no plugin\'s hooks yet (1.0.41), so nothing is held in Grok' : `off: Homie's hooks have not run in ${name} on this computer`,
+      ...(seen ? { seen: { at: new Date(seen.at).toISOString(), event: seen.event } } : {}),
+      unlocks: 'a wait for your own "proceed <code>" before a production deploy, an edit to a file the studio protects, a Cloudflare change outside the deploy, a paid call past the budget and a model download; and secrets taken out of what your AI reads',
+      fix: on ? null : {
+        who: 'person',
+        say: app === 'codex'
+          ? 'In Codex, open /hooks and trust Homie\'s three hooks: Codex runs no plugin\'s hooks until you do. Then run this again. Until then nothing is held, so your AI asks you before each of those itself.'
+          : 'Nothing to do on your side: Grok Build 1.0.41 runs no plugin\'s hooks (none are registered in its headless and agent sessions, from any plugin; checked 2026-10-04), so Homie\'s holds are off in Grok. Nothing is held and no secret is taken out of what your AI reads, so your AI asks you before each of those itself. This row turns on by itself when a Grok that runs them leaves the hooks\' mark.',
+      },
     });
   }
 
@@ -306,7 +432,8 @@ export async function setupStatus({
     { feature: 'Two-browser checks and playtests', state: ready(by.chrome.state), needs: ['chrome'] },
     { feature: 'Sound effects and a theme (free)', state: ready(by.ffmpeg.state), needs: ['ffmpeg'] },
     { feature: 'Put the studio online', state: ready(by.cloudflare.parts[0].state === 'ok' ? by.cloudflare.parts[1].state : by.cloudflare.parts[0].state), needs: ['cloudflare'] },
-    { feature: 'List games in the homie.rocks directory', state: ready(by.connector.state), needs: ['connector'] },
+    // Listing needs the directory, not the connector: `homie-studio publish` reaches it from this computer.
+    { feature: 'List games in the homie.rocks directory', state: by.connector.state === 'ok' || net.ok ? 'ready' : 'not yet', needs: ['connector'] },
     { feature: 'Backup and pull requests', state: ready(by.github.state), needs: ['github'] },
     { feature: 'Songs and game scores', state: ready(by.elevenlabs.state), needs: ['elevenlabs'] },
     { feature: 'Painted art and generated video', state: ready(by.fal.state), needs: ['fal'] },

package/lib/feedback.mjs

@@ -20,10 +20,10 @@
 import { redactText } from './redact.mjs';
 
 export const FEEDBACK_KINDS = Object.freeze(['stuck', 'confusing', 'idea', 'praise', 'bug']);
-export const FEEDBACK_APPS = Object.freeze(['claude-code', 'codex', 'claude-desktop', 'claude-ai', 'other']);
+export const FEEDBACK_APPS = Object.freeze(['claude-code', 'codex', 'grok', 'claude-desktop', 'claude-ai', 'other']);
 export const FEEDBACK_LIMITS = Object.freeze({ text: 1500, raw: 6000, lines: 30, step: 80, email: 254, version: 32, perSession: 5, offers: 3 });
 export const KIND_LABEL = Object.freeze({ stuck: 'Stuck', confusing: 'Confusing', idea: 'Idea', praise: 'Praise', bug: 'Bug' });
-export const APP_LABEL = Object.freeze({ 'claude-code': 'Claude Code', codex: 'Codex', 'claude-desktop': 'the Claude desktop app', 'claude-ai': 'Claude on the web or a phone', other: 'another app' });
+export const APP_LABEL = Object.freeze({ 'claude-code': 'Claude Code', codex: 'Codex', grok: 'Grok', 'claude-desktop': 'the Claude desktop app', 'claude-ai': 'Claude on the web or a phone', other: 'another app' });
 
 /** Where a note goes on a Homie directory (homie.rocks, or a local one for tests). */
 export const feedbackUrl = (directory = 'https://homie.rocks') => `${String(directory || 'https://homie.rocks').replace(/\/+$/, '')}/api/feedback/tell`;
@@ -175,6 +175,7 @@ export async function sendNote(note, { directory, source = 'plugin', consent = '
 export function appOf(clientInfo) {
   const name = String(clientInfo?.name ?? '').toLowerCase();
   if (/codex/.test(name)) return 'codex';
+  if (/grok/.test(name)) return 'grok';
   if (/claude[-_ ]?code/.test(name)) return 'claude-code';
   if (/claude/.test(name)) return 'claude-desktop';
   return 'other';

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/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

@@ -422,11 +422,16 @@ chat's card follows the work from then on) and, for a studio still being set up,
   studio.json as \`cloudflare.domain\`.
 - A game's room size is its netplay manifest's \`maxPlayers\` (game.json \`netplay\`, or netplay.json), up to 32.
 - Nothing in this studio needs \`~/.homie\` or a Homie box.
+- This studio is this folder. A studio in a folder beside it (another folder with its own \`studio.json\`) is
+  somebody else's work: never read it or copy from it unless the person asks.
 - Optional in studio.json: \`"protect"\` (globs of files the owner wants to look at before any change, such as
   \`"games/*/game.json"\`) and \`"budget"\` (\`{ "usd": <n>, "credits": <n> }\`: the most the studio's media jobs spend
   in all). In Claude Code, the Homie plugin's mod holds an edit to a protected file, a deploy, and a paid call past
-  the budget until the person says Proceed, and takes keys out of command output. When it refuses a call, say what
-  you meant to do and why; do not retry it unless the person asks.
+  the budget until the person says Proceed, and takes keys out of command output. In Codex the plugin's hooks hold
+  the same calls until the person's own \`proceed <code>\`, once the person has trusted them; in Grok Build nothing
+  holds them yet. \`npx --no-install homie-studio setup status --client codex\` (or \`grok\`) says whether Homie's
+  holds are on, and while they are off, ask before each of those yourself. When a call is refused, say what you
+  meant to do and why; do not retry it unless the person asks.
 
 ## Telling Homie
 

package/lib/template-history.json

@@ -1471,6 +1471,86 @@
      }
     }
    }
+  },
+  "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"
+      }
+     }
+    }
+   }
+  },
+  "0.30.2": {
+   "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": "13617a3dd1a66be6",
+     "## 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.30.0",
+  "version": "0.30.2",
   "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/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.30.0';
+export const STUDIO_VERSION_TAG = '0.30.2';