@homie-rocks/studio 0.30.1 → 0.30.2

package/CHANGELOG.md

@@ -17,9 +17,44 @@ 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)
+**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.
 

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

@@ -1511,6 +1511,46 @@
      }
     }
    }
+  },
+  "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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homie-rocks/studio",
-  "version": "0.30.1",
+  "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.1';
+export const STUDIO_VERSION_TAG = '0.30.2';