@homie-rocks/studio 0.31.0 → 0.32.0

package/lib/directory.mjs

@@ -16,10 +16,11 @@ import { partsPlanLines, partsPublishReport } from './parts-build.mjs';
  * `publishesLeft`, or those inside `quota` / `limits` / `rateLimit`), or the standard rate-limit headers
  * (`ratelimit-remaining`, `x-ratelimit-remaining`, `retry-after`). What it finds is said after every publish.
  *
- * Before a publish there is nothing to ask (the directory has no "how many are left" call this toolkit knows), so
- * the toolkit says what THIS COMPUTER knows: how many it has sent today (UTC, the day the cap counts in), and
- * what the directory said was left after the last one. That is a floor, never a promise: a publish from another
- * computer or from the Homie connector is not counted here.
+ * Before a publish, `publishBefore` asks the directory itself, with a read (GET /api/studio/publish?site=<origin>
+ * answers { ok, site, listed, limit, remaining, resetsAt } and changes nothing). When the directory cannot be
+ * reached, or is one that has no such read, it says so plainly and falls back to what THIS COMPUTER knows: how many
+ * it has sent today (UTC, the day the cap counts in), and what the directory said was left after the last one. That
+ * is a floor, never a promise: a publish from another computer or from the Homie connector is not counted here.
  */
 const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : typeof v === 'string' && /^\d+$/.test(v.trim()) ? Number(v) : null);
 const first = (...values) => { for (const v of values) { const n = num(v); if (n !== null) return n; } return null; };
@@ -82,16 +83,67 @@ export function partsForListing(root) {
   return { ...report, games, ok: games.every((g) => g.ok) && !report.why };
 }
 
-export async function publish(root, { homie, site, log = () => {}, fetchFn } = {}) {
-  const studio = readStudio(root);
-  const directory = (homie || studio.homie?.directory || 'https://homie.rocks').replace(/\/+$/, '');
-  const url = site || siteUrl(root, studio);
-  // Licences first: a public game may ship only assets with a licence record that allows it.
+/** The asset licence problems that stop a listing: a public game may ship only assets with a licence record that allows it. */
+function licenceRefusals(root) {
   const refused = [];
   for (const g of listGames(root)) {
     if (g.launch === 'private' || g.launch === 'invite') continue;
     for (const p of licenceProblems(root, g.id, readManifest(root, g.id))) if (p.level === 'refuse') refused.push({ game: g.id, ...p });
   }
+  return refused;
+}
+
+/**
+ * `homie-studio publish --before` and the studio_publish tool's `before: true`, one code path: what a publish would
+ * meet, and NOTHING is published. It sends one GET (the directory's own read-only count for this site), never a
+ * POST, and writes no file, not even this computer's count. { ok: true, published: false, listed, publishes: {
+ * remaining, limit, resetsAt, sentToday, from: 'directory' | 'this computer', line }, parts?, refused? }, and
+ * `unreached: { why }` when the directory could not be asked. `ok` says the preflight ran, never that a publish
+ * would go through.
+ */
+export async function publishBefore(root, { homie, site, log = () => {}, fetchFn } = {}) {
+  const studio = readStudio(root);
+  const directory = (homie || studio.homie?.directory || 'https://homie.rocks').replace(/\/+$/, '');
+  const url = site || siteUrl(root, studio);
+  const refused = licenceRefusals(root);
+  const parts = partsForListing(root);
+  const local = publishesSoFar(root);
+  const mine = `this computer has sent ${local.sent} publish${local.sent === 1 ? '' : 'es'} today (UTC)${local.remaining !== null ? `, and the directory said ${local.remaining === 0 ? 'none were' : `${local.remaining} ${local.remaining === 1 ? 'was' : 'were'}`} left after the last one${local.limit !== null ? ` (of ${local.limit} a day)` : ''}` : ''}; a publish from another computer or from the Homie connector is not counted here`;
+  let origin = null;
+  try { origin = url ? new URL(url).origin : null; } catch { origin = null; }
+  let asked = null;
+  if (origin) asked = await request(`${directory}/api/studio/publish?site=${encodeURIComponent(origin)}`, { method: 'GET', headers: { accept: 'application/json' } }, { timeout: 15_000, ...(fetchFn ? { fetchFn } : {}) });
+  const q = asked?.ok ? quotaOf(asked.body, asked.headers) : null;
+  const counted = Boolean(q && q.remaining !== null);
+  const listed = asked?.ok && typeof asked.body?.listed === 'boolean' ? asked.body.listed : null;
+  const why = !origin ? null : asked.ok ? 'it answered without a count' : String(asked.body?.message ?? asked.why ?? 'no answer').split('\n')[0];
+  const line = !origin
+    ? 'Not published. This studio has no live site yet, so there is nothing to list: put it online first (npm run deploy).'
+    : counted
+      ? `Not published. The directory says: this site is ${listed === true ? 'listed' : listed === false ? 'not listed yet' : 'known to it or not, it did not say'}; ${quotaLine(q).replace(/^P/, 'p')}`
+      : `Not published. The directory could not be asked how many publishes are left (${why}), so this is only what this computer knows: ${mine}.`;
+  const lines = [
+    line,
+    ...(refused.length ? [`A publish now would be refused: ${refused.length} asset licence problem${refused.length === 1 ? '' : 's'} (${refused.slice(0, 6).map((p) => `${p.game}/${p.asset}: ${p.problem}`).join('; ')}${refused.length > 6 ? '; …' : ''}). homie-studio assets check <id> says how to fix each.`] : []),
+    ...partsPlanLines(parts, { at: 'publish' }),
+  ];
+  for (const l of lines) log(l);
+  return {
+    ok: true, command: 'publish before', published: false, directory, site: url ?? null, listed,
+    publishes: { remaining: counted ? q.remaining : local.remaining, limit: (counted ? q.limit : null) ?? local.limit, resetsAt: q?.resetsAt ?? null, sentToday: local.sent, from: counted ? 'directory' : 'this computer', line },
+    ...(origin && !counted ? { unreached: { why, ...(asked.status !== undefined ? { status: asked.status } : {}) } } : {}),
+    ...(refused.length ? { refused } : {}),
+    ...(parts.games.length || parts.sharing.length || parts.why ? { parts } : {}),
+    lines,
+  };
+}
+
+export async function publish(root, { homie, site, log = () => {}, fetchFn } = {}) {
+  const studio = readStudio(root);
+  const directory = (homie || studio.homie?.directory || 'https://homie.rocks').replace(/\/+$/, '');
+  const url = site || siteUrl(root, studio);
+  // Licences first: a public game may ship only assets with a licence record that allows it.
+  const refused = licenceRefusals(root);
   if (refused.length) return { ok: false, command: 'publish', refused, why: `not listed: ${refused.length} asset licence problem${refused.length === 1 ? '' : 's'}:\n${refused.map((p) => `  ${p.game}/${p.asset}: ${p.problem}${p.fix ? ` (${p.fix})` : ''}`).join('\n')}\nhomie-studio assets check <id> says the same; fix them, deploy, then publish again.` };
   if (!url) return { ok: false, command: 'publish', why: 'this studio has no live site yet: run `npm run deploy` first' };
   // Parts from other studios in the games about to be listed: their licences and credits, and plainly when two

package/lib/doctor.mjs

@@ -11,8 +11,8 @@
  *                                  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
+ *                                  them on (Codex: trust them in /hooks; Grok Build: trust the plugin, which
+ *                                  `grok plugin install … --trust` does). 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)
@@ -27,6 +27,9 @@
  *   Stripe             for selling only in a studio with shop.json (0.24.3): Stripe's own agent plugin (its MCP server
  *                                  and skills) for this AI, set up when the studio starts selling; the shop's key itself
  *                                  goes in through `homie-studio shop connect`, never here
+ *   Standalone builds  optional    only in a studio where a game.json has a "standalone" block: Xcode, the Android SDK
+ *                                  and a JDK it builds on, Apple signing (a count of identities, never a name),
+ *                                  notarization and steamcmd (lib/standalone.mjs standaloneRows)
  *   Clef locally       optional    Ollama with clef-flash: AI under dev for free (never downloaded without a yes)
  *   status line        optional    (Claude Code only) the build's progress under the prompt
  *
@@ -47,7 +50,8 @@ import { detectLocalAi } from './local-ai.mjs';
 import { findChrome } from './chrome.mjs';
 import { whyFailed } from './net.mjs';
 import { isOurs } from './statusline.mjs';
-import { findStudio, readLocal, readStudio } from './studio.mjs';
+import { findStudio, listGames, readLocal, readStudio } from './studio.mjs';
+import { standaloneRows } from './standalone.mjs';
 import { projectsCloudflareEnv, projectsElevenLabs } from './projects-env.mjs';
 import { STUDIO_VERSION } from './version.mjs';
 
@@ -271,26 +275,27 @@ export async function setupStatus({
     });
   }
 
-  // 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.
+  // Homie's holds, in Codex and Grok Build: each app runs a plugin's hooks only once the person has trusted them
+  // (Codex in /hooks, Grok by trusting the plugin), and neither says so when it skips them. The hooks leave a dated
+  // mark at every message and tool call; a fresh one means they are on. (0.30.2 said Grok runs no plugin's hooks.
+  // It does: the plugin's root manifest named no hooks file, so Grok loaded the Claude Code mod's and found none.)
   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,
+      // Off is the person's to fix now, in either app: trust the hooks.
+      id: 'holds', label: 'Homie\'s holds', need: 'recommended', state: on ? 'ok' : 'act', 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`,
+          : `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.',
+          : 'Grok runs a plugin\'s hooks only once the plugin is trusted, and only from a Homie plugin new enough to name them for Grok. Install it again with trust (grok plugin install homie-rocks/homie#plugins/homie --trust), start a new session (/hooks lists Homie\'s three), then run this again. Until then nothing is held, so your AI asks you before each of those itself.',
       },
     });
   }
@@ -414,6 +419,14 @@ export async function setupStatus({
     });
   }
 
+  // Standalone copies (standalone/STANDALONE.md), only in a studio where a game has a "standalone" block: what the
+  // desktop and phone builds need here. Every one is optional: a target whose tool is missing is skipped, never blocking.
+  {
+    let asked = false;
+    try { asked = Boolean(root) && listGames(root).some((g) => g.standalone && typeof g.standalone === 'object'); } catch { asked = false; }
+    if (asked) rows.push(...await standaloneRows({ platform, exec, env }));
+  }
+
   // The Claude Code status line (only in Claude Code, only in a studio).
   if (root && env.CLAUDECODE === '1') {
     let on = false;

package/lib/mcp-tools.mjs

@@ -31,7 +31,7 @@ import { repoFromUrl, studioRepo } from './repo.mjs';
 import { GAME_ID, PACKAGE_ROOT, findStudio, listGames, readLocal, readStudio, siteUrl } from './studio.mjs';
 import { runningDev } from './dev.mjs';
 import { deployWords } from './deploy-state.mjs';
-import { beforeLine, partsForListing, publishesSoFar } from './directory.mjs';
+import { partsForListing, publishBefore, publishesSoFar } from './directory.mjs';
 import { STUDIO_VERSION } from './version.mjs';
 import { compareVersions, whatsNew, whatsNewLines } from './changelog.mjs';
 import { pinnedVersion } from './upgrade.mjs';
@@ -42,6 +42,7 @@ import { pictureFor } from './pictures.mjs';
 import { ART_UI, artToolDefs } from './art-tools.mjs';
 // GAME PARTS (parts/PARTS.md): parts_find, part_add, part_new and part_share are lib/parts-tools.mjs.
 import { PARTS_FIRST, partsToolDefs } from './parts-tools.mjs';
+import { standaloneToolDefs } from './standalone-tools.mjs';
 import { partsPlanLines } from './parts-build.mjs';
 import { FEEDBACK_APPS, FEEDBACK_KINDS, FEEDBACK_LIMITS, appOf, cleanNote, draftId, noteBlock, sendNote, withLine } from './feedback.mjs';
 
@@ -1085,7 +1086,7 @@ export function toolDefs(ctx, avail = {}) {
     {
       name: 'studio_deploy', title: 'Put the studio online',
       description: 'Put the studio\'s site online on the studio\'s OWN Cloudflare account: one Worker, one D1 database and two Durable Objects, free plan, no payment method. Call it with plan: true first and tell the person in two or three lines what it creates and costs. If Cloudflare is not signed in, cloudflare_login opens it in their browser to approve once. Runs in the background with the build card.',
-      inputSchema: { type: 'object', properties: { plan: { type: 'boolean', description: 'Only say what it will create and what it costs; change nothing' }, ...STUDIO_ARG } },
+      inputSchema: { type: 'object', properties: { plan: { type: 'boolean', description: 'Only say what it will create and what it costs; change nothing' }, ownRoute: { type: 'boolean', description: 'Only after the plan or a deploy warned that another site\'s route on the studio\'s custom domain covers its hostname, and the person agreed: add the studio\'s own exact-host route (the one line the warning gives) and deploy. It never edits or removes any other route' }, ...STUDIO_ARG } },
       annotations: { title: 'Put the studio online', readOnlyHint: false, destructiveHint: false, openWorldHint: true }, _meta: ui(UI.build),
       run: async (a) => {
         const root = ctx.root(a.studio);
@@ -1095,10 +1096,10 @@ 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 ?? ''}`, ...(p.parts ? partsPlanLines(p.parts) : []), '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 });
+          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 ?? ''}`, ...(p.parts ? partsPlanLines(p.parts) : []), ...(p.zone?.warning ? [`Warning (say this to the person as it is): ${p.zone.warning}`] : p.zone?.why ? [p.zone.why] : []), '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'] }] });
+        return startRun(ctx, root, { kind: 'deploy', game: null, title: `${studio.name}: online`, steps: [{ label: 'deploy', args: ['deploy', ...(a.ownRoute === true ? ['--own-route'] : [])] }] });
       },
     },
     {
@@ -1119,18 +1120,22 @@ export function toolDefs(ctx, avail = {}) {
     },
     {
       name: 'studio_publish', title: 'List the studio in the Homie directory',
-      description: 'List a deployed studio\'s games, songs and videos in the homie.rocks directory, with their Play links (at most 12 games per studio in the beta). The beta also caps how many times a studio may publish in a day: the answer says how many are left when the directory gives the number, and before: true only says what this computer knows (how many it has sent today, what the directory last said was left) without publishing.',
-      inputSchema: { type: 'object', properties: { site: str('Optional: the live site address (default: the one deploy got)'), before: { type: 'boolean', description: 'Only say how many publishes this computer has sent today and what the directory last said was left; publish nothing' }, ...STUDIO_ARG } },
+      description: 'List a deployed studio\'s games, songs and videos in the homie.rocks directory, with their Play links (at most 12 games per studio in the beta). The beta also caps how many times a studio may publish in a day: the answer says how many are left when the directory gives the number, and before: true publishes nothing: it asks the directory how many are left and whether the site is listed (a read), and says so plainly when the directory cannot be reached.',
+      inputSchema: { type: 'object', properties: { site: str('Optional: the live site address (default: the one deploy got)'), before: { type: 'boolean', description: 'Publish nothing: ask the directory (a read) whether this site is listed and how many publishes are left today, and say the parts\' licence lines. When the directory cannot be reached it says so, with what this computer has sent today' }, ...STUDIO_ARG } },
       annotations: { title: 'List in the directory', readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
       run: async (a) => {
         const root = ctx.root(a.studio);
-        // What this computer knows of the day's cap, before anything is sent (lib/directory.mjs).
-        const soFar = beforeLine(publishesSoFar(root));
         // The parts in the games a listing shows, in the deploy plan's own lines (licences, credits, and plainly when
         // two cannot be combined): said before the studio is listed, and again with the answer.
         const partsNow = partsForListing(root);
         const partsSaid = partsPlanLines(partsNow, { at: 'publish' });
-        if (a.before === true) return ok([`${soFar.replace(/^Publishing to the directory: /, 'Not published. ')} A publish from another computer or from the Homie connector is not counted here.`, ...partsSaid].join('\n'), { kind: 'publish-count', ...publishesSoFar(root), ...(partsSaid.length ? { parts: partsNow } : {}) });
+        // before: true is `publish --before`, the same function the terminal runs (lib/directory.mjs publishBefore):
+        // the directory's read-only count for this site, the parts' lines, and nothing published. Run here, by THIS
+        // toolkit, never handed to the studio's pinned one: a 0.31.0 toolkit reads `publish --before` as `publish`.
+        if (a.before === true) {
+          const b = await publishBefore(root, { site: a.site ? String(a.site) : undefined });
+          return ok(b.lines.join('\n'), { kind: 'publish-count', ...publishesSoFar(root), ...b });
+        }
         const r = await cli(ctx, root, 'publish', ['publish', ...(a.site ? ['--site', String(a.site)] : [])]);
         if (!r.ended) return stillRunning(r.job, 'Listing');
         if (r.job.code !== 0) return fail(`Not listed: ${whyOf(r.job)}`, r.result?.publishes ? { kind: 'publish', ok: false, needs: r.result.needs ?? null, publishes: r.result.publishes } : undefined);
@@ -1264,7 +1269,7 @@ export function toolDefs(ctx, avail = {}) {
     },
     {
       name: 'studio_job', title: 'A job, so far',
-      description: 'Where a job a tool handed back is (an npm install, a check, a deploy, a render): running or done, its last lines and its result. Waits up to 30 s for it to finish.',
+      description: 'Where a job a tool handed back is (an npm install, a check, a deploy, a render, a standalone build): running or done, its last lines and its result. A result that comes with its own words for the person (a standalone build\'s) is given in those words: read them to the person. Waits up to 30 s for it to finish.',
       inputSchema: { type: 'object', properties: { job: str('The job id (j_…)') }, required: ['job'] },
       annotations: { title: 'A job', ...RO },
       run: async (a) => {
@@ -1273,7 +1278,7 @@ export function toolDefs(ctx, avail = {}) {
         await waitJob(job, Math.min(ctx.waitMs, 30_000));
         const v = jobView(job, { lines: 20 });
         if (job.endedAt) ctx.status = null;
-        return ok(`${v.label}: ${v.state}${v.state === 'running' ? ` (${v.seconds} s so far)` : ` after ${v.seconds} s`}${v.state === 'failed' ? `: ${whyOf(job)}` : ''}${v.result ? `\n${JSON.stringify(v.result, null, 1).slice(0, 8000)}` : v.tail.length ? `\n${v.tail.join('\n')}` : ''}`, { kind: 'job', ...v });
+        return ok(`${v.label}: ${v.state}${v.state === 'running' ? ` (${v.seconds} s so far)` : ` after ${v.seconds} s`}${v.state === 'failed' ? `: ${whyOf(job)}` : ''}${Array.isArray(v.result?.say) && v.result.say.length ? `\n${v.result.say.join('\n').slice(0, 16_000)}` : v.result ? `\n${JSON.stringify(v.result, null, 1).slice(0, 8000)}` : v.tail.length ? `\n${v.tail.join('\n')}` : ''}`, { kind: 'job', ...v });
       },
     },
     {
@@ -1362,6 +1367,8 @@ export function toolDefs(ctx, avail = {}) {
   // Art direction, the cast, the starter library, generated props, checks, the lineup and the rights (lib/art-tools.mjs).
   tools.push(...artToolDefs(ctx, { ok, fail, cli, stillRunning, whyOf, needsInstall, ui, str, STUDIO_ARG, RO, RW, pictureFor, findNode, startJob, waitJob }));
   tools.push(...partsToolDefs(ctx, { ok, fail, str, STUDIO_ARG, RO, RW }));
+  // A game as an app of its own, for computers and phones (lib/standalone-tools.mjs).
+  tools.push(...standaloneToolDefs(ctx, { ok, fail, cli, stillRunning, whyOf, needsInstall, str, STUDIO_ARG }));
   const topics = guideTopics(ctx);
   if (topics.length) {
     tools.push({

package/lib/mcp.mjs

@@ -53,6 +53,8 @@ To make one mechanic of a game feel better (a jump, a hit, a dash), game_lab ope
 
 A game's look is a set of decisions (render style, palette, light, camera, fonts, the cast and its budgets), automatic from the person's words until they steer or lock one (studio_guide { "topic": "style" }). style_explore draws three directions with the game engine for free; decision_set picks, steers and locks; assets_find searches the free CC0 starter library and asset_add copies a model in with its licence; asset_make makes a prop on the person's own fal account only after they agreed to its price; asset_check, asset_lineup and asset_rights keep it one game, phone-sized and properly licensed (studio_guide { "topic": "models" }).
 
+A game as an app of its own (a desktop app for macOS, Windows and Linux; an iPhone or Android app): game_standalone, with plan: true first. It is the same web game in a thin shell and still plays through the studio's own site. Say plainly what its plan says a standalone copy does not have (no accounts, cloud saves, shop or chat), that a build is the kind of file Steam or a store accepts for upload and never a promise it is accepted, that nothing is uploaded for them, and what its result says was started and what was only built (studio_guide { "topic": "standalone" }).
+
 Telling Homie (homie_feedback): when the person is stuck, confused or frustrated, after an error you could not fix, or at the end of their first studio setup or first publish, you may OFFER, once a session, to send the people who make Homie a short note about it. Draft it in plain words from what happened (it sends nothing), show it exactly as it would go (its card has Send, Edit and Don't send), and send only after they say yes. Never nag: a no is final for the session. When they ask to tell Homie something, draft it with offered: false.
 
 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.`;

package/lib/parts.mjs

@@ -6,6 +6,7 @@
  * is `parts/<id>/part.json` and the files beside it. A part is a piece of a game, never the whole game.
  *
  *   checkPart()        the shape of a part.json, each problem in plain words with its fix
+ *   previewAspect()    a preview's declared shape ("4:3") as two whole numbers, or null: the only reading of it
  *   hashDir()          every file of a part with its SHA-256 and size (node:crypto): written by the tool, never by hand
  *   newPart()          a part lifted out of one of the studio's games (the game still builds and plays the same)
  *   fileRights()       whose each file is: its own record, a game's asset record of the same bytes, or the part's provenance
@@ -42,6 +43,30 @@ const clean = (s, n = 300) => (typeof s === 'string' ? s.replace(/[\x00-\x1f\x7f
 const isObj = (v) => Boolean(v) && typeof v === 'object' && !Array.isArray(v);
 export const sha256 = (bytes) => createHash('sha256').update(bytes).digest('hex');
 
+/* ------------------------------------------------------------------ a preview's shape */
+
+/**
+ * The shape of a part's preview frame: `preview.aspect`, and `preview.phoneAspect` for a frame narrower than
+ * 600 CSS px. Each is "W:H" in whole numbers 1 to 32, no flatter than 3:1 and no taller than 1:2. The default
+ * is 16:9, which on a 390 px phone is a frame about 197 px tall: too short for a preview somebody plays with.
+ */
+const PREVIEW_SHAPE = Object.freeze({ max: 32, flattest: 3, tallest: 2 });
+/** { w, h } for a shape inside those bounds; null for anything else (the page then uses the default). */
+export function previewAspect(value) {
+  const m = typeof value === 'string' ? /^([1-9]\d?):([1-9]\d?)$/.exec(value) : null;
+  if (!m) return null;
+  const w = Number(m[1]); const h = Number(m[2]);
+  if (w > PREVIEW_SHAPE.max || h > PREVIEW_SHAPE.max || w > PREVIEW_SHAPE.flattest * h || h > PREVIEW_SHAPE.tallest * w) return null;
+  return { w, h };
+}
+/** Why a declared shape is refused, in plain words; null when it is fine. */
+function aspectProblem(value) {
+  if (previewAspect(value)) return null;
+  const m = typeof value === 'string' ? /^([1-9]\d?):([1-9]\d?)$/.exec(value) : null;
+  if (!m || Number(m[1]) > PREVIEW_SHAPE.max || Number(m[2]) > PREVIEW_SHAPE.max) return 'it is not a shape: two whole numbers from 1 to 32 with a colon between them';
+  return Number(m[1]) > Number(m[2]) ? 'it is flatter than 3:1, too short a frame to show a part in' : 'it is taller than 1:2, too tall a frame to fit a screen';
+}
+
 /* ------------------------------------------------------------------ versions and ranges */
 
 const VERSION = /^(\d{1,6})\.(\d{1,6})\.(\d{1,6})(?:-[0-9A-Za-z.-]{1,40})?$/;
@@ -241,6 +266,8 @@ export function checkPart(part, { id = null } = {}) {
     else {
       if (part.preview.page != null && (!safePath(part.preview.page) || !/\.html?$/.test(part.preview.page))) bad('preview.page', 'it is not an HTML file inside the part', 'preview/index.html');
       if (part.preview.image != null && (!safePath(part.preview.image) || !/\.(png|jpe?g|webp|gif|svg)$/i.test(part.preview.image))) bad('preview.image', 'it is not a picture inside the part', 'preview/cover.jpg');
+      // The frame's shape. Refused, never repaired: the studio's page builds its CSS from these two numbers and nothing else.
+      for (const k of ['aspect', 'phoneAspect']) if (part.preview[k] !== undefined && aspectProblem(part.preview[k])) bad(`preview.${k}`, aspectProblem(part.preview[k]), k === 'aspect' ? '"4:3", "1:1", "3:4"; leave it out for 16:9' : '"3:4" or "1:1": the shape on a phone; leave it out for the usual one');
       const listed = new Set((Array.isArray(part.files) ? part.files : []).map((f) => f?.path));
       for (const k of ['page', 'image']) if (part.preview[k] && Array.isArray(part.files) && safePath(part.preview[k]) && !listed.has(part.preview[k])) bad(`preview.${k}`, `${part.preview[k]} is not one of the part's files`, 'check the path; checking the part rewrites its file list');
     }

package/lib/routes.mjs

@@ -16,8 +16,17 @@
  * So: the routes the owner wrote for the studio's OWN hostnames (a custom domain, an exact host) are kept across
  * every rewrite; a wildcard or catch-all route is never deployed by the studio unless studio.json says the zone is
  * the studio's (`cloudflare.allowWildcardRoutes: true`); and a deploy whose domain answers as something else says
- * which route is needed. Nothing here calls Cloudflare: a zone's other routes belong to other Workers, and the
- * studio never lists, changes or removes one.
+ * which route is needed.
+ *
+ *   4. The zone ALREADY has another site's catch-all or wildcard route, and the studio's custom domain sits beside
+ *      it. The studio's own config is clean, so nothing above speaks; the route answers the studio's hostname first,
+ *      and the tempting repair (edit or remove that route) takes the other site down. So a deploy and its plan READ
+ *      the zone's Worker routes when the studio has a custom domain (readZoneRoutes: two GETs with the sign-in
+ *      Wrangler already has, never a write) and say, before anything is deployed, that the route is another site's,
+ *      must not be edited or removed, and which one line makes the studio's hostname its own (zoneFinding). A list
+ *      that cannot be read is said as unmeasured, never as fine.
+ *
+ * The studio never changes or removes a route it did not make: a zone's other routes belong to other Workers.
  */
 import { readFileSync } from 'node:fs';
 import { configPath } from './studio.mjs';
@@ -130,3 +139,102 @@ export function shadowedDomain(config, hostname, answer = {}) {
     why: `https://${host} ${said}, not as this studio: something else on the domain answers that hostname first. The usual reason is another Worker's route on the same zone that covers it (a wildcard like "*${route.zone_name}/*", or a catch-all): Cloudflare matches a route before a custom domain. The studio does not touch that route (it is not the studio's). Add the studio's own exact-host route to "routes" in wrangler.jsonc, which wins over a wildcard for this one hostname, and deploy again: ${JSON.stringify(route)} (zone_name is the domain as it is named in Cloudflare). Every deploy keeps it.`,
   };
 }
+
+/* ------------------------------------------------------------------ the zone's routes, beside the studio's domain */
+
+const CF_API = 'https://api.cloudflare.com/client/v4';
+
+/** The zones a hostname may be in, likeliest first: the ones the config's routes name, then each parent of the hostname. */
+export function zoneCandidates(hostname, config = null) {
+  const parts = String(hostname ?? '').toLowerCase().split('.').filter(Boolean);
+  const named = routesOf(config).map((r) => String(r.zone_name ?? '').toLowerCase()).filter(Boolean);
+  const parents = [];
+  for (let i = 0; i <= parts.length - 2; i += 1) parents.push(parts.slice(i).join('.'));
+  return [...new Set([...named, ...parents])].slice(0, 6);
+}
+
+/**
+ * The Worker routes of the zone a hostname is in, READ from Cloudflare (GET /zones?name=…, then GET
+ * /zones/<id>/workers/routes) with headers the toolkit already has (lib/brain-probe.mjs cloudflareAuth: Wrangler's
+ * own sign-in). { read: true, zone: { id, name }, routes: [{ pattern, script }] }, or { read: false, why } when it
+ * could not be read (no sign-in, a sign-in that may not read the zone, no such zone on it, no network). It never
+ * writes. `fetchFn` stands in for the network in tests.
+ */
+export async function readZoneRoutes({ hostname, config = null, headers = null, fetchFn = globalThis.fetch, base = CF_API, ms = 10_000 } = {}) {
+  if (!headers) return { read: false, why: 'this computer has no Cloudflare sign-in to read them with' };
+  const root = String(base).replace(/\/+$/, '');
+  const get = async (path) => {
+    const res = await fetchFn(`${root}${path}`, { headers: { ...headers, accept: 'application/json', 'user-agent': 'homie-studio-deploy' }, signal: AbortSignal.timeout(ms) });
+    let body = null;
+    try { body = await res.json(); } catch { body = null; }
+    return { status: res.status, ok: res.ok && body?.success !== false, result: Array.isArray(body?.result) ? body.result : null };
+  };
+  const refused = (status) => (status === 401 || status === 403 ? 'this Cloudflare sign-in may not read the domain\'s routes' : `Cloudflare answered ${status}`);
+  try {
+    let zone = null;
+    for (const name of zoneCandidates(hostname, config)) {
+      const r = await get(`/zones?name=${encodeURIComponent(name)}`);
+      if (!r.ok || !r.result) return { read: false, why: refused(r.status) };
+      const hit = r.result.find((z) => String(z?.name ?? '').toLowerCase() === name && z?.id);
+      if (hit) { zone = { id: String(hit.id), name }; break; }
+    }
+    if (!zone) return { read: false, why: `no domain that ${String(hostname).toLowerCase()} belongs to is on the Cloudflare account this computer is signed in to` };
+    const r = await get(`/zones/${encodeURIComponent(zone.id)}/workers/routes`);
+    if (!r.ok || !r.result) return { read: false, zone, why: refused(r.status) };
+    return { read: true, zone, routes: r.result.filter((x) => typeof x?.pattern === 'string' && x.pattern.trim()).map((x) => ({ pattern: x.pattern.trim(), script: x.script ? String(x.script) : null })) };
+  } catch (error) {
+    return { read: false, why: error?.name === 'TimeoutError' ? `Cloudflare did not answer in ${Math.round(ms / 1000)} s` : `Cloudflare could not be reached (${String(error?.cause?.code ?? error?.code ?? error?.message ?? error).slice(0, 80)})` };
+  }
+}
+
+const NOT_OURS = 'Never edit or remove a route this studio did not make';
+
+/**
+ * What the zone's routes mean for a studio on a custom domain, in words for the plan, the terminal and the tool
+ * result. `zone` is readZoneRoutes' answer; `worker` the studio's own Worker; `config` its wrangler.jsonc.
+ *   state 'clear'       no other route covers the studio's hostname: nothing to say (`why` is null)
+ *   state 'foreign'     another site's wildcard or catch-all covers it and the studio has no exact-host route of its
+ *                       own: `warning`, with the one line to add (`route`, `line`)
+ *   state 'own-route'   another site's route covers it, and the studio's own exact-host route already wins for its
+ *                       hostname: `why` says to leave the other route alone
+ *   state 'taken'       the studio's own hostname is routed to another Worker: only the person can decide that
+ *   state 'unmeasured'  the list could not be read: said as that, with the reason
+ */
+export function zoneFinding({ hostname, worker = null, config = null, zone = null } = {}) {
+  const host = String(hostname ?? '').toLowerCase();
+  const guess = zone?.zone?.name ?? likelyZone(host);
+  const route = exactRouteFor(host, guess);
+  const line = JSON.stringify(route);
+  const ownInConfig = sortRoutes(config).own.find((r) => routeKind(r) === 'exact-host' && routeHost(r) === host) ?? null;
+  if (!zone?.read) {
+    return {
+      state: 'unmeasured', host, zone: zone?.zone?.name ?? null, foreign: [], route, line,
+      why: `Not checked: whether another site's route on the domain covers ${host} (${zone?.why ?? 'not read'}). That is unmeasured, not a pass. If ${host} answers as something else after a deploy, the fix is the studio's own exact-host route in "routes" in wrangler.jsonc, ${line} (zone_name is the domain as Cloudflare names it), which every deploy keeps. ${NOT_OURS}.`,
+    };
+  }
+  const others = zone.routes.filter((r) => r.script !== worker && routeCovers(r, host)).map((r) => ({ pattern: r.pattern, script: r.script, kind: routeKind(r) }));
+  const taken = others.filter((r) => r.kind === 'exact-host');
+  const wide = others.filter((r) => r.kind !== 'exact-host');
+  const said = (list) => list.map((r) => `"${r.pattern}" (${r.script ? `Worker ${r.script}` : 'no Worker: it turns Workers off for what it covers'})`).join(', ');
+  const base = { host, zone: zone.zone.name, route, line };
+  if (taken.length) {
+    return {
+      ...base, state: 'taken', foreign: others,
+      warning: `${host} itself is routed to another Worker on ${zone.zone.name}: ${said(taken)}. That route is not this studio's, so the studio does not take, edit or remove it, and neither should you: whatever it serves would stop answering. Only the person can decide to hand the hostname over, in the domain's Workers Routes in the Cloudflare dashboard; or give the studio a hostname nothing else uses (studio.json cloudflare.domain).`,
+    };
+  }
+  if (!wide.length) return { ...base, state: 'clear', foreign: [], why: null };
+  const ownLive = zone.routes.find((r) => r.script === worker && routeKind(r) === 'exact-host' && routeHost(r) === host) ?? null;
+  const all = wide.some((r) => r.kind === 'catch-all');
+  const them = `${wide.length === 1 ? 'a route' : 'routes'} that cover${wide.length === 1 ? 's' : ''} ${host} and ${wide.length === 1 ? 'is' : 'are'} not this studio's: ${said(wide)}`;
+  if (ownInConfig || ownLive) {
+    return {
+      ...base, state: 'own-route', foreign: wide,
+      why: `${zone.zone.name} has ${them}. ${wide.length === 1 ? 'It belongs' : 'They belong'} to another site on this domain and must not be edited or removed. The studio's own exact-host route ("${(ownInConfig ?? ownLive).pattern}") wins over ${wide.length === 1 ? 'it' : 'them'} for this one hostname, and every deploy keeps it: nothing to change.`,
+    };
+  }
+  return {
+    ...base, state: 'foreign', foreign: wide,
+    warning: `${zone.zone.name} already has ${them}. ${wide.length === 1 ? 'That route belongs' : 'Those routes belong'} to another site on this domain: ${wide.length === 1 ? 'it' : 'they'} must not be edited or removed, here or in the Cloudflare dashboard, or that site stops answering. Cloudflare matches a route before a custom domain, so ${all ? 'the catch-all' : 'the wildcard'} answers ${host} first and the studio's own domain would show the other site. The one safe fix is the studio's own exact-host route, which wins over a wider route for this one hostname only and which every deploy keeps. Add this line to "routes" in wrangler.jsonc and deploy: ${line} (or \`homie-studio deploy --own-route\`, which adds exactly that line and nothing else).`,
+  };
+}

package/lib/scaffold.mjs

@@ -281,7 +281,7 @@ studio's pinned copy, never a registry lookup of the bare name.
   does not raise the callout.
 - **The frame has no storage of its own.** The game runs in a sandboxed frame without \`allow-same-origin\` (a
   stranger's game must never read this site's storage or the owner's session), so \`localStorage\` throws inside it.
-  A setting or a personal best goes in \`net.prefs\` (\`await net.prefs.get('quality', 'high')\`,
+  A setting or a personal best goes in \`net.prefs\` (\`net.prefs.string('quality', 'high')\`, \`net.prefs.number('volume', 0.8, { min: 0, max: 1 })\` after \`await net.prefs.ready\`: the typed readers give your fallback for a missing key, never a null that turns into 0,
   \`net.prefs.set('quality', 'low')\`: the play page keeps 16 KB a game); progress that must last goes in saves.
   The play page's \`?debug\` and \`?q=…\` reach the game as \`net.params\`, with any names game.json
   \`"netplay": { "params": ["seed"] }\` declares (\`NETPLAY.md\` section 24).
@@ -489,8 +489,8 @@ chat's card follows the work from then on) and, for a studio still being set up,
   \`"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. 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
+  the same calls until the person's own \`proceed <code>\`, once the person has trusted them, and in Grok Build once
+  the plugin is trusted. \`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.
 

package/lib/standalone-cli.mjs

@@ -0,0 +1,106 @@
+/**
+ * `homie-studio standalone …`: a game as a desktop app (macOS, Windows, Linux) and a phone app (iOS, Android): the
+ * files Steam and the stores accept for upload. lib/standalone.mjs does the work; standalone/STANDALONE.md is the
+ * guide. In chat it is the game_standalone tool (lib/standalone-tools.mjs).
+ *
+ *   standalone plan <game> [--for mac,windows,linux,ios,android] [--release] [--site <address>]
+ *       what would be built, with what, what each target still needs on this computer, and what a standalone copy
+ *       does not have. Changes nothing, installs nothing.
+ *   standalone build <game> [--for …] [--release] [--site <address>] [--build <n>]
+ *       builds the game for the web, then every target this computer can make; one it cannot is skipped with why.
+ *   standalone run <game> [--for ios|android]      the built copy, started here (none: this computer's desktop app)
+ *   standalone steam <game>                        Steam's build files from game.json's numbers; uploads nothing
+ *   standalone ci <game>                           .github/workflows/standalone.yml: every target on GitHub's machines
+ *
+ * `on` (tests): the computer the command is run "on" (its platform, environment and tools), handed to the library.
+ */
+import { STANDALONE_VERBS, standaloneBuild, standaloneCi, standalonePlan, standaloneRun, standaloneSteam } from './standalone.mjs';
+
+export { STANDALONE_VERBS };
+
+/** What follows the list of what a standalone copy lacks, wherever an AI reads it: never softened, never left out. */
+export const SAY_MISSING = 'Say this to the person as it is, before they ship anything: it is what a player of the standalone game does not get.';
+
+export async function standaloneCommand(root, sub, positional, flags, { log = () => {}, on = {} } = {}) {
+  const id = positional[2] ?? null;
+  const str = (k) => (typeof flags.get(k) === 'string' ? flags.get(k) : null);
+  // `--for` with nothing after it is passed on as it is (true), so the command can refuse it: never "all five".
+  const opts = { for: flags.has('for') ? flags.get('for') : null, release: flags.has('release'), site: str('site'), build: flags.has('build') ? flags.get('build') : null, log, ...on };
+  /*
+   * WHAT A PERSON IS TOLD rides in the result itself (`say`): the same lines the command prints, then the instruction
+   * about the missing list. A chat tool that started this as a job and reads the result later (studio_job) says
+   * these lines, not a page of JSON with the list buried in it.
+   */
+  const told = (r) => (r && (r.targets || r.rows) ? { ...r, say: [...standaloneLines(r), '', SAY_MISSING] } : r);
+  switch (sub ?? 'plan') {
+    case 'plan': return told(await standalonePlan(root, id, opts));
+    case 'build': return told(await standaloneBuild(root, id, opts));
+    case 'run': return standaloneRun(root, id, { for: flags.has('for') ? flags.get('for') : null });
+    case 'steam': return standaloneSteam(root, id);
+    case 'ci': return standaloneCi(root, id);
+    default: return { ok: false, command: 'standalone', why: `"${sub}" is not a standalone command: ${STANDALONE_VERBS.join(', ')}` };
+  }
+}
+
+/* ------------------------------------------------------------------ plain lines */
+
+const MARK = { ready: '→', built: '✓', skipped: '○', failed: '✗' };
+const fixLine = (t) => (t.fix ? `      ${t.fix.run ? `${t.fix.run}  ` : ''}${t.fix.open ? `${t.fix.open}  ` : ''}${t.fix.say ?? ''}` : null);
+
+/** What a standalone copy does not have, under the heading every surface uses. */
+export function missingLines(missing) {
+  return ['What the standalone game does not have (v1):', ...missing.map((m) => `  - ${m.what}: ${m.why}.`)];
+}
+
+export function standaloneLines(r) {
+  const L = [];
+  // A refusal with something to do about it (a release with no id yet, Steam with no numbers) still says it all.
+  if (r.ok === false && !r.targets && !r.rows) { L.push(r.why ?? 'failed'); if (r.instead) L.push('', r.instead); return L; }
+  switch (r.command) {
+    case 'standalone plan': {
+      L.push(`${r.name} as a standalone game${r.release ? ' (a release)' : ' (a build to try)'}: ${r.appId}${r.appIdFrom === 'derived' ? ' (made up for now)' : ''}, version ${r.version} build ${r.build}, held ${r.orientation === 'any' ? 'any way' : r.orientation}.`,
+        `  The same web build of the game, in Electron on computers and Capacitor on phones. Everything is made in ${r.dir}/ (never committed).`,
+        `  Rooms: ${r.site ? `${r.site} (${r.siteFrom})` : 'none: this copy would play offline only'}${r.netplayVersion ? `, netplay version "${r.netplayVersion}"` : ''}.`,
+        `  Icon: ${r.icon.note}.`, '');
+      for (const t of r.targets) {
+        L.push(`  ${MARK[t.state]} ${t.target.padEnd(8)} ${t.state === 'ready' ? `${t.with}: ${t.output}` : `SKIPPED here: ${t.why}`}`);
+        if (t.state === 'skipped') { const f = fixLine(t); if (f) L.push(f); if (t.instead) L.push(`      ${t.instead}`); }
+      }
+      L.push('', 'On this computer:');
+      for (const row of r.rows) L.push(`  ${row.state === 'ok' ? '✓' : '○'} ${row.label} (${row.need}): ${row.detail}`);
+      if (r.warnings.length) L.push('', ...r.warnings.map((w) => `Warning: ${w}`));
+      L.push('', r.toolkitNote ?? r.needs, '', ...missingLines(r.missing));
+      if (r.ok === false) L.push('', r.why, '', r.instead);
+      break;
+    }
+    case 'standalone build': {
+      L.push(`${r.name} ${r.version} build ${r.build}${r.release ? ' (release)' : ''}, ${r.appId}${r.appIdFrom === 'derived' ? ' (made up for now)' : ''}: in ${r.dir}/`);
+      for (const t of r.targets) {
+        L.push(`  ${t.unsigned ? '!' : MARK[t.state]} ${t.target.padEnd(8)} ${t.state === 'built' ? `${t.unsigned ? 'BUILT, UNSIGNED (no store takes it): ' : ''}${t.path}` : t.state === 'skipped' ? `SKIPPED: ${t.why}` : `FAILED: ${t.why}`}`);
+        for (const n of t.notes ?? []) L.push(`      ${n}`);
+        if (t.state === 'skipped') { const f = fixLine(t); if (f) L.push(f); if (t.instead) L.push(`      ${t.instead}`); }
+      }
+      L.push(`  Rooms: ${r.site ?? 'none: these copies play offline only'}. Icon: ${r.icon.note}.`);
+      if (r.warnings.length) L.push('', ...r.warnings.map((w) => `Warning: ${w}`));
+      if (r.next.length) L.push('', 'Next, by you (nothing was uploaded):', ...r.next.map((n) => `  ${n}`));
+      if (r.toolkitNote) L.push('', r.toolkitNote);
+      L.push('', ...missingLines(r.missing));
+      if (r.ok === false) L.push('', `NOT DONE: ${r.why}`);
+      break;
+    }
+    case 'standalone run':
+      L.push(`${r.game} (${r.target}) ended.`);
+      break;
+    case 'standalone steam':
+      L.push(`Steam's build file for app ${r.app}: ${r.dir}/${r.wrote.join(', ')} (each depot is that system's release build, out/<system>/release/).`,
+        ...(r.unbuilt.length ? [`  NO RELEASE BUILD YET for ${r.unbuilt.join(', ')} (its depot would upload nothing): homie-studio standalone build ${r.game} --for ${r.unbuilt.join(',')} --release`] : []),
+        'In Steamworks:', ...r.setup, `  ${r.upload}`, r.note);
+      break;
+    case 'standalone ci':
+      L.push(`${r.changed ? 'Wrote' : 'Unchanged:'} ${r.file}.`, ...r.next.map((n) => `  ${n}`));
+      break;
+    default:
+      L.push(JSON.stringify(r));
+  }
+  return L;
+}