@homie-rocks/studio 0.26.1 → 0.28.0

package/CHANGELOG.md

@@ -17,9 +17,72 @@ 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.28.0] - 2026-10-03
+
+**Plugin 0.29.0** · [#43](https://github.com/homie-rocks/homie/pull/43)
+
+Tell Homie: when something confuses you or gets in your way, Claude can offer to send the people who make Homie a short note about it. You see the note word for word first, and nothing is sent without your yes.
+
+### Added
+
+- `homie_feedback`, a new tool on both Homie MCP servers (the remote one at homie.rocks, and the local `homie-studio mcp` in Homie for Claude Desktop), with the same name and inputs on each:
+  - `draft` (the default) sends nothing. It answers with the note exactly as it would go: its kind (stuck, confusing, idea, praise or bug), the words, and what goes with them (the step or skill, the studio's and the plugin's versions, the app, and whether Claude offered it or you asked). Keys, tokens, private links, code, home folders, email addresses, network addresses and your Cloudflare account's name are taken out first, and the note says what was taken out.
+  - `send` sends only the note you were shown. It names the draft, and a note whose words or details changed since then is refused.
+  - `decline` records your no.
+  - A note goes only to homie.rocks: a studio.json can name Homie's own directory or this computer, nothing else.
+- A Tell Homie card in Claude Desktop and Claude on the web or a phone: the note as it would go, with **Send**, **Edit** (your own words, your kind, an optional reply address) and **Don't send**.
+- In Claude Code, the Homie mod:
+  - `/feedback <your words>` shows your note in a Tell Homie pane with Send and Don't send. `/feedback` alone opens the pane to write one, or puts an ask for Claude to draft one in your prompt box. The Studio pane has a **Tell Homie** button (`t`).
+  - Every send from Claude waits for **Send** in Claude Code's own question, with the note's exact words. Once you have sent or declined a note in a session, Claude cannot offer another.
+  - A note is drawn in the transcript as a framed note.
+- In Codex, Homie's hooks hold every send until your own `proceed <code>`, with the note's exact words in the hold.
+- Skills and the studio's `AGENTS.md` (a new "Telling Homie" section) tell Claude when to offer: after an error it could not fix, when you sound confused or frustrated, and at the end of your first studio setup or first publish. It offers at most once a session, never makes help wait on it, and takes no for an answer.
+
+### Changed
+
+- The studio-setup and publish skills, the plugin's README and both MCP servers' instructions describe Tell Homie.
+
+### Upgrade notes
+
+- Nothing to do. `homie-studio upgrade` adds the "Telling Homie" section to the studio's `AGENTS.md`. The tool is on the Homie MCP for every app; in Claude Code, update the plugin for `/feedback` and the send hold. Notes are private; homie.rocks/privacy says what is kept.
+
+## [0.27.0] - 2026-10-03
+
+**Plugin 0.28.0** · [#42](https://github.com/homie-rocks/homie/pull/42) · [release-2026-10-03-studio-0.27.0](https://github.com/homie-rocks/homie/releases/tag/release-2026-10-03-studio-0.27.0)
+
+Search engines and AI agents read a studio's site correctly: schema.org data on every page, a full VideoGame on every landing, and a sitemap, robots.txt and llms.txt made from what is public.
+
+### Added
+
+- Structured data (schema.org JSON-LD) on every generated page, from the studio's own files and nothing else:
+  - Home: the studio as an `Organization` (its name, address, logo, share picture and tagline) and its `WebSite`.
+  - Each game's landing: a `VideoGame` (co-typed `WebApplication`, as Google asks) with its description and pitch, pictures and screenshots, genre, players (fewest and most), play modes, platforms, the studio as author and publisher, the source's licence (linked to its SPDX page when it names one), what it is based on (a remix's original page, a port's original), its trailer as a `VideoObject`, when it came out and last changed, a Play action and a free-to-play offer.
+  - Music: `MusicRecording` (the studio as the artist, its length, its audio file, its cover, its key and date) and a `MusicAlbum` when the music manifest names one. Videos: `VideoObject` (poster, upload date, length, the file itself). Posts: `BlogPosting` and the studio's `Blog`. Games and Rooms: an `ItemList` of the public games. Every page but Home: a `BreadcrumbList`.
+- Never a rating or a review, and no price for anything the shop does not sell. While your shop really sells, each item sold in a game is an add-on of that game's free offer, in real money. The Rooms page's data names the games, never who is playing this minute.
+- `/robots.txt`, `/sitemap.xml`, `/llms.txt` and `/llms-full.txt`, made from your public catalogue:
+  - robots.txt lets crawlers read every public page, keeps them off your office, the APIs, accounts and each game's play, TV, watch and socket doors, and names the sitemap. A Preview asks not to be crawled.
+  - The sitemap lists Home, Games and each landing, Music, Videos, Rooms, Posts and your own pages, with dates only where a real date says when each changed.
+  - llms.txt tells an AI agent what your studio is: each game with its pitch, players, Play, Watch and big-screen links; which games are open to remix, with the licence, the source and the words to say to Claude Code or Codex with Homie; songs, videos, posts with their feeds, your own pages, and homie.rocks's llms.txt. llms-full.txt adds each game's whole description, how to play and credits, and every post's text.
+  - A private or invite-only game is in none of them, and a game is offered for remixing only when its source is shared, your Remixable switch is on and its licence allows it.
+- game.json takes `"genre"` (a word, or up to three), `"released"` (the day it came out) and `"schema"` (schema.org properties of your own on the game). studio.json takes `"site": { "schema": { … } }` for the studio, such as `"sameAs"` links to its other pages. Homie's own properties always win, and ratings, reviews and offers are refused (the build says so).
+- Screenshots: pictures in `games/<id>/screenshots/` (or game.json `landing.screenshots`), at most eight, get a band on the landing and go into its VideoGame. A game's genre shows with its room facts.
+- A video's or song's `"date"` in its manifest; without one, when it was made (`made.at`). Search engines show no video without an upload date, so the build says when a video has neither.
+- `<!-- homie:schema -->` in the `<head>` of a page of your own (`site/pages`) puts there the structured data the generated page would carry.
+- `lib/schema-check.mjs` checks every JSON-LD block of a page against schema.org's own vocabulary (types, properties, which type each property is for, value kinds, enumerations) and against what Google documents as required for VideoGame, VideoObject, BreadcrumbList, ItemList, BlogPosting, Organization and MusicRecording.
+
+### Changed
+
+- A landing's VideoGame was a short block with a price of 0 and no co-type; it is now the full record above, inside one `@graph` with the page's breadcrumbs.
+- A private or invite-only game's landing, which only its owner and invitees see, answers `x-robots-tag: noindex`.
+
+### Upgrade notes
+
+- Nothing to do: `homie-studio upgrade` and a deploy bring all of it. Give each game a `"genre"`, put a few pictures of real play in `games/<id>/screenshots/`, give each video a `"date"` if it has no `made.at`, and add your studio's other pages to `studio.json` `"site": { "schema": { "sameAs": [...] } }`.
+- A `robots.txt`, `sitemap.xml`, `llms.txt` or `llms-full.txt` you already keep in `site/public/` still wins over the made one. A landing or Home page of your own in `site/pages/` is left exactly as it is; add `<!-- homie:schema -->` to its `<head>` to give it the structured data.
+
 ## [0.26.1] - 2026-10-03
 
-**Plugin 0.27.1** · [#41](https://github.com/homie-rocks/homie/pull/41)
+**Plugin 0.27.1** · [#41](https://github.com/homie-rocks/homie/pull/41) · [release-2026-10-03-studio-0.26.1](https://github.com/homie-rocks/homie/releases/tag/release-2026-10-03-studio-0.26.1)
 
 In Codex, Homie now holds what the Claude Code mod holds: protected files, deploys, Cloudflare changes, spending past the budget and model downloads wait for your own "proceed", and secrets come out of what Codex reads.
 

package/README.md

@@ -49,6 +49,14 @@ feed; MCP Apps cards (setup, build progress, studio, codex) are served as `ui://
 answers in plain text. Homie for Claude Desktop (`desktop/` in this repository) is this server as a Desktop
 Extension: the plain Claude app gets it with one install, and no terminal.
 
+**Tell Homie** (0.28.0): `homie_feedback` drafts a short note to the people who make Homie (stuck, confusing, idea,
+praise or bug) from what happened, and sends it only after the person has seen it word for word and said yes: its
+card (`ui://homie-studio/feedback`) has Send, Edit and Don't send, and a send must name the draft the person saw,
+with the same words. Keys, home folders, email addresses, code and a workers.dev account name are taken out before
+it is shown (`lib/feedback.mjs`, with the Homie mod's own redaction). Claude offers one at most once a session, and a
+no is final for it. It goes to homie.rocks (`/api/feedback/tell`): a studio.json can name only Homie's own directory or
+this computer, so a borrowed studio cannot send notes elsewhere.
+
 ## From a phone: a one-line hand-off
 
 The Claude app on a phone hands a build to a Claude Code cloud session with one line, `Continue building <Studio>:
@@ -107,6 +115,14 @@ in that palette, light or dark as its paper is (0.26.0). Every HTML answer is `n
 site. A game made with Homie's arcade controls that knocks for a Homie box (`/__homie/call`) is told
 `not-a-homie`, at the site's root as under the game.
 
+Search engines and AI agents read a studio correctly (0.27.0): every generated page carries schema.org JSON-LD
+(`worker/schema.mjs`: the studio's `Organization` and `WebSite` on Home, a full `VideoGame` on each landing with its
+players, platforms, licence, remix original, trailer, dates and a free-to-play offer whose add-ons are what the shop
+really sells, `MusicRecording`, `VideoObject`, `BlogPosting`, `ItemList` and `BreadcrumbList`; never a rating), and the
+site makes `/robots.txt`, `/sitemap.xml`, `/llms.txt` and `/llms-full.txt` from its public catalogue
+(`worker/discover.mjs`). `lib/schema-check.mjs` checks every block against schema.org's own vocabulary and what Google
+documents as required. game.json `"schema"` and studio.json `site.schema` add the owner's own properties.
+
 Anyone can **watch** a live room from any player's view at `/<game>/watch?room=<room>` (a Watch button sits beside
 Join on every room): the game itself, drawn by the watcher's own browser as a watcher that never takes a seat,
 with a strip of the players to switch between (a tap, keys 1-9, Auto, the whole room). A game draws the followed
@@ -777,7 +793,8 @@ pinned a tarball at `https://homie.rocks/npm/homie-studio-<version>.tgz`, which
 ## Beta
 
 This is a beta. Bugs, port requests and questions go to
-<https://github.com/homie-rocks/homie/issues/new/choose>.
+<https://github.com/homie-rocks/homie/issues/new/choose>, or, from inside Claude or Codex, to the people who make
+Homie as a short note you see and send yourself (`homie_feedback`, above).
 
 ## License
 

package/lib/build.mjs

@@ -40,7 +40,9 @@ import { join, relative } from 'node:path';
 import { buildCodexPages } from './codex.mjs';
 import { servedAssets } from './asset-manifest.mjs';
 import { buildMedia } from './media.mjs';
-import { buildSiteFiles, landingOf, readPosts, readTheme } from './site.mjs';
+import { buildSiteFiles, isoDate, landingOf, readPosts, readTheme } from './site.mjs';
+import { checkJsonLd } from './schema-check.mjs';
+import { SCHEMA_REFUSED } from '../worker/schema.mjs';
 import { PACKAGE_ROOT, listGames, readStudio } from './studio.mjs';
 import { SEAT_MAX } from '../worker/seats.mjs';
 import { STUDIO_VERSION } from './version.mjs';
@@ -152,6 +154,57 @@ function readJson(path) {
   try { return JSON.parse(readFileSync(path, 'utf8')); } catch { return null; }
 }
 
+/**
+ * When a game came and last changed (its landing's datePublished and dateModified, and the sitemap's lastmod):
+ * game.json `"released"` (a day) when the owner says so, else the commit that added its game.json; and the last
+ * commit that touched its folder. Nothing from a shallow clone (its first commit would claim every file was made that
+ * day) or a folder git does not track.
+ */
+export function gameDates(root, g, log = () => {}) {
+  const git = (args) => { try { const r = spawnSync('git', args, { cwd: root, encoding: 'utf8', timeout: 5000 }); return r.status === 0 ? r.stdout.trim() : null; } catch { return null; } };
+  const released = isoDate(g.released);
+  if (g.released !== undefined && !released) log(`warning: games/${g.id}/game.json "released" is a day (2026-09-30); left out`);
+  const shallow = git(['rev-parse', '--is-shallow-repository']);
+  if (shallow !== 'false') return released ? { published: released } : null;
+  const rel = relative(root, g.dir).split('\\').join('/');
+  const added = git(['log', '--diff-filter=A', '--format=%cI', '--', `${rel}/game.json`])?.split('\n').filter(Boolean).pop() ?? null;
+  const last = git(['log', '-1', '--format=%cI', '--', rel]) || null;
+  const iso = (v) => (v && Number.isFinite(Date.parse(v)) ? new Date(Date.parse(v)).toISOString() : null);
+  const out = { published: released ?? iso(added), modified: iso(last) };
+  if (out.published && out.modified && Date.parse(out.modified) < Date.parse(out.published)) out.modified = out.published;
+  return out.published || out.modified ? Object.fromEntries(Object.entries(out).filter(([, v]) => v)) : null;
+}
+
+/**
+ * The owner's own structured data (game.json "schema", studio.json "site": { "schema" }): a plain object of schema.org
+ * properties put on the game's VideoGame (the studio's Organization), under Homie's own. Ratings, reviews and offers
+ * are refused (Homie shows no ratings on the page; prices are shop.json's), and so is anything that is not JSON-LD a
+ * page can carry; a property schema.org does not have, or does not put on that type, is warned about.
+ */
+export function schemaExtras(value, { where, types, log = () => {} }) {
+  if (value === undefined) return null;
+  if (!value || typeof value !== 'object' || Array.isArray(value)) { log(`warning: ${where} "schema" is an object of schema.org properties; left out`); return null; }
+  const out = {};
+  for (const [k, v] of Object.entries(value)) {
+    if (SCHEMA_REFUSED.includes(k)) { log(`warning: ${where} schema.${k} is left out: Homie publishes no ${k === 'offers' ? 'prices but the shop\'s (shop.json)' : 'ratings or reviews the page does not show'}`); continue; }
+    if (!/^[a-z][A-Za-z0-9]{0,63}$/.test(k)) { log(`warning: ${where} schema "${k.slice(0, 40)}" is not a property name (Homie sets @type and @id); left out`); continue; }
+    out[k] = v;
+  }
+  const json = JSON.stringify(out);
+  if (json.length > 8192) { log(`warning: ${where} "schema" is over 8 KB; left out`); return null; }
+  const { errors } = checkJsonLd({ '@context': 'https://schema.org', '@type': types, ...out });
+  for (const e of errors) log(`warning: ${where} schema: ${e.replace(/^\$: /, '')}`);
+  return Object.keys(out).length ? out : null;
+}
+
+/** game.json "genre": a word or up to three ("Arcade", ["Racing", "Party"]); its landing and VideoGame say it. */
+export function genreOf(g, log = () => {}) {
+  if (g.genre === undefined) return null;
+  const list = (Array.isArray(g.genre) ? g.genre : [g.genre]).filter((x) => typeof x === 'string' && x.trim()).map((x) => x.trim().slice(0, 40)).slice(0, 3);
+  if (!list.length) log(`warning: games/${g.id}/game.json "genre" is a word or a list of up to three; left out`);
+  return list.length ? list : null;
+}
+
 /**
  * A game's netplay manifest: game.json's `netplay` block, over a `netplay.json` beside game.json or in the game's
  * built output (a ported Vite game ships public/netplay.json), over nothing.
@@ -357,6 +410,11 @@ export async function build(root, { only = null, log = () => {}, deploy = proces
     // The game's own palette (style.json, its art direction): the play page's buttons wear its paper and ink, so the
     // page's pills and the game's own HUD are one UI.
     const ui = uiOf(g);
+    // Search engines and agents (0.27.0, worker/schema.mjs): its genre, when it came and last changed, and the owner's
+    // own schema.org properties.
+    const genre = genreOf(g, log);
+    const dates = gameDates(root, g, log);
+    const extras = schemaExtras(g.schema, { where: `games/${g.id}/game.json`, types: ['VideoGame', 'WebApplication'], log });
     return {
       id: g.id, name: g.name ?? g.id, blurb: g.blurb ?? '', players: { min, max },
       ...(ui ? { ui } : {}),
@@ -384,6 +442,9 @@ export async function build(root, { only = null, log = () => {}, deploy = proces
       // Its source licence (worker/license.mjs), and, for a remix, what it is a remix of (shown on its landing).
       license: licenseOf(g.license),
       ...(remixRow(g.remixOf) ? { remixOf: remixRow(g.remixOf) } : {}),
+      ...(genre ? { genre } : {}),
+      ...(dates ? { dates } : {}),
+      ...(extras ? { schema: extras } : {}),
       landing: landingOf(g, join(dist, 'games', g.id), { videos: media.videos, songs: media.songs, log }),
     };
   });
@@ -394,11 +455,14 @@ export async function build(root, { only = null, log = () => {}, deploy = proces
   mkdirSync(join(dist, '_site'), { recursive: true });
   writeFileSync(join(dist, '_site', 'posts.json'), `${JSON.stringify({ v: 1, posts })}\n`);
   const s = studio.site && typeof studio.site === 'object' ? studio.site : {};
+  const studioExtras = schemaExtras(s.schema, { where: 'studio.json site', types: 'Organization', log });
   const catalogue = {
     studio: {
       name: studio.name, slug: studio.slug, version: STUDIO_VERSION,
       ...(typeof studio.tagline === 'string' && studio.tagline.trim() ? { tagline: studio.tagline.trim().slice(0, 140) } : {}),
       theme,
+      // studio.json "site": { "schema": { … } }: the owner's own schema.org properties on the studio (sameAs, …).
+      ...(studioExtras ? { schema: studioExtras } : {}),
       site: {
         ...(rows.some((g) => g.id === s.featured) ? { featured: s.featured } : {}),
         ...(Array.isArray(s.frameAncestors) ? { frameAncestors: s.frameAncestors.filter((o) => /^https:\/\/[a-z0-9.-]+(?::\d+)?$/i.test(String(o))).slice(0, 8) } : {}),

package/lib/feedback.mjs

@@ -0,0 +1,181 @@
+/**
+ * TELL HOMIE (0.28.0): a short note from a creator to the people who make Homie, drafted by Claude in plain words,
+ * shown to the person exactly as it would go, and sent ONLY after they say yes. One module for every road a note
+ * takes from this side: the local MCP's `homie_feedback` (lib/mcp-tools.mjs), its card (mcp/ui/feedback.js), and
+ * the rules the Homie mod and the remote Homie MCP keep the same (homie.rocks has its own copy of these rules and
+ * applies them again when a note arrives).
+ *
+ * What a note is, and nothing more: its kind (stuck, confusing, idea, praise, bug), the words, the step or skill it
+ * is about, the studio and plugin versions, which app it came from, whether Claude offered it or the person asked,
+ * and a reply address only when the person typed one. No file, no log, no code, no key, no studio name, no path.
+ *
+ * Before anything is shown, the words go through the mod's own redaction (lib/redact.mjs, the same rules the mod
+ * uses on tool output: keys, tokens, private keys, owner links) and then a note's own: fenced code, home folders
+ * (a user's home becomes ~), email addresses, a workers.dev address's account name, network addresses and long
+ * opaque strings. What was taken out is listed with the draft, so the person sees it too.
+ *
+ * THE DRAFT IS THE NOTE. A draft's id is a hash of everything that would be sent; a send carries the id and the same
+ * fields, and a send whose fields do not hash to its id is refused. So what goes out is exactly what was shown.
+ */
+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_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' });
+
+/** 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`;
+
+const EMAIL = /^[^\s@]{1,64}@[^\s@]{1,255}\.[^\s@]{2,63}$/;
+const VERSION = /^[0-9A-Za-z][0-9A-Za-z.+-]{0,31}$/;
+const CONTROL = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f\u2028\u2029\u200b-\u200f\u202a-\u202e\u2060-\u206f\ufeff]/g;
+const HIDDEN = (what) => `[${what} hidden by Homie]`;
+
+/*
+ * A note's own rules, after the mod's. Each: what it is (said to the person), the pattern, and its replacement.
+ * Order matters: code first (whatever is inside a fence goes whole), then links and addresses.
+ */
+const NOTE_RULES = [
+  { kind: 'code', re: /```[\s\S]*?(?:```|$)/g, to: () => '[code left out by Homie]' },
+  // A workers.dev address names the Cloudflare account, often after its owner: the account part goes.
+  // (Labels are bounded, as DNS bounds them: an unbounded one makes this rule quadratic on a long run of hyphens.)
+  { kind: 'a workers.dev account name', re: /\b([a-z0-9-]{1,63}\.)?([a-z0-9-]{1,63})(\.workers\.dev)\b/gi, to: (m, sub, account, tail) => `${sub ?? ''}[account]${tail}` },
+  { kind: 'a home folder', re: /(?:\/Users\/|\/home\/)([^/\s"'`]+)/g, to: () => '~' },
+  { kind: 'a home folder', re: /\b[A-Za-z]:\\Users\\([^\\\s"'`]+)/g, to: () => '~' },
+  { kind: 'an email address', re: /\b[A-Za-z0-9._%+-]{1,64}@[A-Za-z0-9.-]{1,253}\.[A-Za-z]{2,63}\b/g, to: () => HIDDEN('an email address') },
+  // A network address that is not this computer's own.
+  { kind: 'a network address', re: /\b(?!127\.0\.0\.1\b)(?!0\.0\.0\.0\b)(?:25[0-5]|2[0-4]\d|1?\d?\d)(?:\.(?:25[0-5]|2[0-4]\d|1?\d?\d)){3}\b/g, to: () => HIDDEN('a network address') },
+  // A signed token (three dotted parts, the first two JSON in base64): whole, before the rule below takes one part.
+  { kind: 'a token', re: /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g, to: () => HIDDEN('a token') },
+  // Anything long and opaque that a rule above did not name (a token of a kind nobody listed, a hash, a blob), after
+  // a dot too.
+  { kind: 'a long code', re: /(?<![A-Za-z0-9_\-+/=])(?=[A-Za-z0-9_\-+/=]*[0-9])(?=[A-Za-z0-9_\-+/=]*[A-Za-z])[A-Za-z0-9_\-+/=]{32,}(?![A-Za-z0-9_\-+/=])/g, to: () => HIDDEN('a long code') },
+];
+
+/** The words of a note as they may go: redacted, plain, and the list of what was taken out. */
+export function redactNote(value) {
+  let text = String(value ?? '').replace(/\r\n?/g, '\n').replace(CONTROL, '');
+  const taken = [];
+  for (const rule of NOTE_RULES.slice(0, 1)) text = applyRule(text, rule, taken);
+  const r = redactText(text);
+  if (r.hits.length) {
+    taken.push(...r.hits.map((h) => (h === 'owner link' ? 'a private link' : `a ${h}`.replace(/^a ([aeiou])/i, 'an $1'))));
+    // The mod's words for a link it showed in its pane are not true of a note: here the link is simply gone.
+    text = r.text.split('[one-time owner link: the Homie mod showed it to the person in its Studio pane; Claude never sees it]').join(HIDDEN('a private link'));
+  }
+  for (const rule of NOTE_RULES.slice(1)) text = applyRule(text, rule, taken);
+  text = text.replace(/[ \t]+\n/g, '\n').replace(/\n{3,}/g, '\n\n').trim();
+  return { text, taken: [...new Set(taken)] };
+}
+
+function applyRule(text, rule, taken) {
+  rule.re.lastIndex = 0;
+  return text.replace(rule.re, (...m) => {
+    const out = rule.to(...m);
+    if (out !== m[0]) taken.push(rule.kind);
+    return out;
+  });
+}
+
+const oneLine = (value, max) => String(value ?? '').replace(CONTROL, ' ').replace(/\s+/g, ' ').trim().slice(0, max);
+
+/**
+ * A note as it may be shown and sent, or why not: { ok: true, note, taken } | { ok: false, why }.
+ * `input`: { kind, text, step?, studioVersion?, pluginVersion?, app?, email?, offered? }.
+ */
+export function cleanNote(input = {}) {
+  const kind = String(input.kind ?? '').trim().toLowerCase();
+  if (!FEEDBACK_KINDS.includes(kind)) return { ok: false, why: `kind is one of ${FEEDBACK_KINDS.join(', ')}` };
+  const raw = String(input.text ?? '');
+  // Before any rule reads it: a note is short, and a rule's cost grows with what it is given.
+  if (raw.length > FEEDBACK_LIMITS.raw) return { ok: false, why: `the note is ${raw.length.toLocaleString('en-US')} characters: keep it under ${FEEDBACK_LIMITS.text.toLocaleString('en-US')} (a short note, never a log or a file)` };
+  const { text, taken } = redactNote(raw);
+  if (!text) return { ok: false, why: 'the note is empty: write what happened in a sentence or two, in plain words' };
+  if (text.length > FEEDBACK_LIMITS.text) return { ok: false, why: `the note is ${text.length} characters: keep it under ${FEEDBACK_LIMITS.text.toLocaleString('en-US')} (a short note, never a log or a file)` };
+  if (text.split('\n').length > FEEDBACK_LIMITS.lines) return { ok: false, why: `the note has more than ${FEEDBACK_LIMITS.lines} lines: a short note, never a log or a file` };
+  const stepRaw = oneLine(input.step, 400);
+  const step = stepRaw ? oneLine(redactNote(stepRaw).text, FEEDBACK_LIMITS.step) || null : null;
+  const version = (v) => { const s = String(v ?? '').trim().replace(/^v/, ''); return VERSION.test(s) ? s : null; };
+  const app = FEEDBACK_APPS.includes(String(input.app ?? '')) ? String(input.app) : 'other';
+  const emailRaw = String(input.email ?? '').trim();
+  if (emailRaw && (emailRaw.length > FEEDBACK_LIMITS.email || !EMAIL.test(emailRaw))) return { ok: false, why: 'the reply address is not a whole email address: leave it out, or ask the person for theirs' };
+  const note = {
+    kind, text, step,
+    studioVersion: version(input.studioVersion), pluginVersion: version(input.pluginVersion),
+    app, email: emailRaw || null, offered: input.offered === true,
+  };
+  return { ok: true, note, taken };
+}
+
+/** A draft's id: what would be sent, hashed. The same note always has the same id; any change gives another. */
+export async function draftId(note) {
+  const canonical = JSON.stringify([note.kind, note.text, note.step, note.studioVersion, note.pluginVersion, note.app, note.email, note.offered]);
+  const digest = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(canonical));
+  return `fd_${[...new Uint8Array(digest)].slice(0, 12).map((b) => b.toString(16).padStart(2, '0')).join('')}`;
+}
+
+/** What goes with the words, in a line the person reads. */
+export function withLine(note) {
+  const parts = [
+    note.step ? `the step (${note.step})` : null,
+    note.studioVersion ? `studio ${note.studioVersion}` : null,
+    note.pluginVersion ? `plugin ${note.pluginVersion}` : null,
+    APP_LABEL[note.app] ?? null,
+    note.offered ? 'that Claude offered it' : 'that you asked to send it',
+  ].filter(Boolean);
+  return `${parts.join(' · ')}. ${note.email ? `A reply address: ${note.email}.` : 'No reply address.'}`;
+}
+
+/** The note, exactly as it would go, as the text a chat shows (for an app with no card). */
+export function noteBlock(note, taken = []) {
+  return [
+    `  Kind: ${KIND_LABEL[note.kind]}`,
+    ...note.text.split('\n').map((l, i, all) => `  ${i === 0 ? '"' : ' '}${l}${i === all.length - 1 ? '"' : ''}`),
+    `  Sent with it: ${withLine(note)}`,
+    ...(taken.length ? [`  Homie took out: ${taken.join(', ')}.`] : []),
+  ].join('\n');
+}
+
+/** The body a Homie directory takes at /api/feedback/tell. `source`: 'plugin' (this toolkit) or 'mod'. */
+export function noteBody(note, { source, consent }) {
+  const body = { kind: note.kind, text: note.text, source, consent, offered: note.offered, app: note.app };
+  for (const k of ['step', 'studioVersion', 'pluginVersion', 'email']) if (note[k]) body[k] = note[k];
+  return body;
+}
+
+/**
+ * Send a note the person said yes to: { ok, reference, repeat } | { ok: false, why, status }. Never retried here:
+ * a second press is the person's to make, and the directory answers a repeat with the same reference.
+ */
+export async function sendNote(note, { directory, source = 'plugin', consent = 'chat', fetchImpl = fetch, timeoutMs = 15_000 } = {}) {
+  let res;
+  try {
+    res = await fetchImpl(feedbackUrl(directory), {
+      method: 'POST',
+      headers: { 'content-type': 'application/json', accept: 'application/json', 'user-agent': `homie-studio-feedback (${source})` },
+      body: JSON.stringify(noteBody(note, { source, consent })),
+      redirect: 'manual',
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+  } catch (error) {
+    return { ok: false, status: 0, why: `Homie could not be reached (${error?.name === 'TimeoutError' ? 'no answer in 15 s' : error?.cause?.code ?? error?.message ?? 'no connection'}). Nothing was sent; the person can try again later.` };
+  }
+  let body = null;
+  try { body = JSON.parse(await res.text()); } catch { body = null; }
+  if (res.ok && body?.ok === true && typeof body.reference === 'string') return { ok: true, reference: body.reference, repeat: body.repeat === true };
+  const said = typeof body?.message === 'string' ? oneLine(body.message, 300) : null;
+  if (res.status === 429) return { ok: false, status: 429, why: said ?? 'Homie has had enough notes from this network today. Nothing was sent; try again tomorrow.' };
+  if (res.status === 404) return { ok: false, status: 404, why: 'This Homie directory does not take notes yet. Nothing was sent.' };
+  return { ok: false, status: res.status, why: `${said ?? `Homie answered ${res.status}`}. Nothing was sent.` };
+}
+
+/** Which app a client is, from its MCP initialize clientInfo. */
+export function appOf(clientInfo) {
+  const name = String(clientInfo?.name ?? '').toLowerCase();
+  if (/codex/.test(name)) return 'codex';
+  if (/claude[-_ ]?code/.test(name)) return 'claude-code';
+  if (/claude/.test(name)) return 'claude-desktop';
+  return 'other';
+}

package/lib/mcp-tools.mjs

@@ -37,6 +37,7 @@ import { detectLocalAi } from './local-ai.mjs';
 import { LAB_PORT, runningLab } from './lab.mjs';
 import { pictureFor } from './pictures.mjs';
 import { ART_UI, artToolDefs } from './art-tools.mjs';
+import { FEEDBACK_APPS, FEEDBACK_KINDS, FEEDBACK_LIMITS, appOf, cleanNote, draftId, noteBlock, sendNote, withLine } from './feedback.mjs';
 
 export const UI = Object.freeze({
   setup: 'ui://homie-studio/setup',
@@ -44,6 +45,7 @@ export const UI = Object.freeze({
   studio: 'ui://homie-studio/studio',
   codex: 'ui://homie-studio/codex',
   lab: 'ui://homie-studio/lab',
+  feedback: 'ui://homie-studio/feedback',
   ...ART_UI,
 });
 
@@ -72,6 +74,10 @@ export class StudioContext {
     this.notes = new Map();
     this.runs = new Map();
     this.status = null;
+    // Tell Homie: this session's drafts (what the person was shown), and whether an offered note was answered.
+    this.feedback = { drafts: new Map(), sent: 0, offers: 0, offeredDone: false, declined: false };
+    // The MCP client (initialize's clientInfo), which a note names as an app and nothing more.
+    this.client = null;
   }
 
   note(root) { if (!this.notes.has(root)) this.notes.set(root, {}); return this.notes.get(root); }
@@ -580,6 +586,110 @@ async function githubLogin(ctx) {
   return ok(`GitHub's sign-in is waiting for the person: open https://github.com/login/device and enter the code ${code} (job ${job.id}; studio_job says when it is done). The code is GitHub's one-time device code, not a password.`, { kind: 'job', ...jobView(job), deviceCode: code });
 }
 
+/* ------------------------------------------------------------------ Tell Homie (lib/feedback.mjs) */
+
+/** The plugin's version, from the skills folder this server was given (the plugin's own manifest beside it). */
+function pluginVersion(ctx) {
+  if (!ctx.skillsDir) return null;
+  for (const f of [join(ctx.skillsDir, '..', '.claude-plugin', 'plugin.json'), join(ctx.skillsDir, '..', 'plugin.json')]) {
+    try { const v = JSON.parse(readFileSync(f, 'utf8')).version; if (typeof v === 'string') return v; } catch { /* not here */ }
+  }
+  return null;
+}
+
+/** What this server knows that a note carries: the toolkit's version (the studio's own pin, in a studio), the plugin's, the app, and where notes go. */
+function feedbackFacts(ctx, studioArg) {
+  let root = null;
+  try { root = ctx.root(studioArg, { need: false }); } catch { root = null; }
+  let studio = null;
+  try { studio = root ? readStudio(root) : null; } catch { studio = null; }
+  const pinned = (() => {
+    try { const pkg = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8')); return pinnedVersion(pkg?.devDependencies?.['@homie-rocks/studio'] ?? pkg?.dependencies?.['@homie-rocks/studio']); } catch { return null; }
+  })();
+  const fromStudio = String(studio?.homie?.directory ?? '');
+  // Where notes go: the directory this server was started with (--homie, the operator's own word), else the studio's,
+  // and a studio.json (which may be a clone of somebody else's) can only name Homie's own directory or this computer.
+  const loopback = (u) => u.protocol === 'http:' && ['127.0.0.1', 'localhost'].includes(u.hostname);
+  const started = (d) => { try { const u = new URL(d); return u.protocol === 'https:' || loopback(u); } catch { return false; } };
+  const homies = (d) => { try { const u = new URL(d); return (u.protocol === 'https:' && /(^|\.)homie\.rocks$/.test(u.hostname)) || loopback(u); } catch { return false; } };
+  const directory = (ctx.directory && started(ctx.directory) ? ctx.directory : null) ?? (fromStudio && homies(fromStudio) ? fromStudio : null) ?? 'https://homie.rocks';
+  return { studioVersion: pinned ?? STUDIO_VERSION, pluginVersion: pluginVersion(ctx), app: appOf(ctx.client), directory: directory.replace(/\/+$/, ''), studio: root ? basename(root) : null };
+}
+
+const hostOfUrl = (u) => { try { return new URL(u).host; } catch { return 'homie.rocks'; } };
+
+/**
+ * homie_feedback: draft (shows the note exactly as it would go, sends nothing), send (only the note a draft showed,
+ * after the person's yes), decline (the person said no: nothing is sent, and no note is offered again this session).
+ *
+ * A send is tied to its draft by the draft's id alone (a hash of the whole note), never by this process's memory: an
+ * app may start a new server between the draft and the yes (a resumed session, a restart), and the remote Homie MCP
+ * keeps no session at all. What this process remembers is only a convenience (a send that names just its draft) and
+ * the once-a-session rule.
+ */
+async function feedbackTool(ctx, a) {
+  const action = ['draft', 'send', 'decline'].includes(a.action) ? a.action : 'draft';
+  const session = ctx.feedback;
+  const facts = feedbackFacts(ctx, a.studio);
+  const to = hostOfUrl(facts.directory);
+  const view = (state, extra = {}) => ({ kind: 'feedback', state, to, ...extra });
+  if (action === 'decline') {
+    const kept = a.draft ? session.drafts.get(String(a.draft)) : null;
+    session.declined = true;
+    if (kept?.note.offered || !kept) session.offeredDone = true;
+    if (kept) session.drafts.delete(String(a.draft));
+    return ok('Not sent: nothing left this computer. Tell the person so in a few words, and do not offer to send a note again in this session.',
+      view('declined', { draft: a.draft ?? null, note: kept?.note ?? null, taken: kept?.taken ?? [], with: kept ? withLine(kept.note) : null, next: 'Not sent. Say so in a few words, and do not offer to send a note again in this session.' }));
+  }
+  // A send of a draft this process showed sends THAT note (its facts are the ones the person saw, whichever studio is
+  // in use now); words that come with it must be its own. A draft it does not know is rebuilt from the call's fields.
+  const known = a.draft ? session.drafts.get(String(a.draft)) : null;
+  const worded = !(a.text === undefined || a.text === null || a.text === '');
+  let c;
+  if (action === 'send' && known) {
+    const said = worded ? cleanNote({ ...known.note, kind: a.kind ?? known.note.kind, text: a.text }) : null;
+    if (said && (!said.ok || said.note.text !== known.note.text || said.note.kind !== known.note.kind)) {
+      return fail('Not sent: this is not the note the person was shown (its words or kind changed since the draft). Draft it again, show them the new note, and send that one after their yes.', view('changed', { draft: String(a.draft), note: known.note, taken: known.taken, with: withLine(known.note), studio: facts.studio, why: 'changed since the draft' }));
+    }
+    c = { ok: true, note: known.note, taken: known.taken };
+  } else {
+    c = cleanNote({ kind: a.kind, text: a.text, step: a.step, email: a.email, offered: a.offered === true, studioVersion: facts.studioVersion, pluginVersion: facts.pluginVersion, app: facts.app });
+  }
+  if (!c.ok) return fail(`Not sent: ${c.why}.`, view('invalid', { why: c.why }));
+  const id = await draftId(c.note);
+  const shown = { draft: id, note: c.note, taken: c.taken, with: withLine(c.note), studio: facts.studio };
+  if (action === 'draft') {
+    if (c.note.offered && (session.declined || session.offeredDone)) {
+      return fail(`Not drafted: ${session.declined ? 'the person said no to a note earlier in this session' : 'a note was already offered in this session'}, and Homie offers at most once a session. Do not offer again. If the person asks, in their own words, to tell Homie something, draft it with offered: false.`, view('invalid', { why: 'offered once already this session' }));
+    }
+    // An offer nobody answered may be reworded a few times (the person asked for a change); it is not asked over and over.
+    if (c.note.offered && !session.drafts.has(id)) {
+      if (session.offers >= FEEDBACK_LIMITS.offers) return fail('Not drafted: a note was offered several times in this session and the person has not said yes. Do not offer again. If they ask to tell Homie something, draft it with offered: false.', view('invalid', { why: 'offered several times already' }));
+      session.offers += 1;
+    }
+    session.drafts.set(id, { note: c.note, taken: c.taken, at: Date.now() });
+    const next = `Nothing has been sent. Show the person this note exactly as it is and ask whether to send it. Only after they say yes in their own words: homie_feedback { "action": "send", "draft": "${id}" } with the same kind and text. If they want it worded differently, draft it again in their words. If they say no: homie_feedback { "action": "decline", "draft": "${id}" }, say nothing was sent, and do not offer again in this session.`;
+    return ok([
+      'Nothing has been sent. Show the person this note exactly as it is (where a card shows, it has Send, Edit and Don\'t send), and ask whether to send it to Homie:',
+      '',
+      noteBlock(c.note, c.taken),
+      '',
+      `Send it only after they say yes in their own words: homie_feedback { "action": "send", "draft": "${id}" } with the same kind and text. If they want it worded differently, draft it again in their words and show the new note. If they say no: homie_feedback { "action": "decline", "draft": "${id}" }, tell them nothing was sent, and do not offer again in this session. It goes privately to the people who make Homie (${to}).`,
+    ].join('\n'), view('draft', { ...shown, next }));
+  }
+  // send
+  if (!a.draft) return fail(`Not sent: a send names the draft the person saw (homie_feedback { "action": "draft", … } first, show it, and send its "draft" id after their yes).`, view('invalid', { why: 'no draft' }));
+  if (String(a.draft) !== id) return fail('Not sent: this is not the note the person was shown (its words or details changed since the draft). Draft it again, show them the new note, and send that one after their yes.', view('changed', { ...shown, why: 'changed since the draft' }));
+  if (session.sent >= FEEDBACK_LIMITS.perSession) return fail(`Not sent: ${FEEDBACK_LIMITS.perSession} notes is the most one session sends.`, view('invalid', { ...shown, why: 'too many this session' }));
+  const r = await sendNote(c.note, { directory: facts.directory, source: 'plugin', consent: ['card', 'dialog'].includes(a.by) ? a.by : 'chat' });
+  if (!r.ok) return fail(`Not sent: ${r.why}`, view('failed', { ...shown, why: r.why }));
+  session.sent += 1;
+  session.drafts.delete(id);
+  if (c.note.offered) session.offeredDone = true;
+  return ok(`Sent to Homie${r.repeat ? ' (it had this exact note already)' : ''}: reference ${r.reference.slice(0, 8)}. Thank the person in one line. The note is private: only the people who make Homie read it. Do not offer another note in this session.`,
+    view('sent', { ...shown, reference: r.reference, next: 'Sent. Thank the person in one line, and do not offer another note in this session.' }));
+}
+
 /* ------------------------------------------------------------------ guides (the plugin's skills) */
 
 function guideTopics(ctx) {
@@ -1120,6 +1230,29 @@ export function toolDefs(ctx, avail = {}) {
         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 });
       },
     },
+    {
+      name: 'homie_feedback', title: 'Tell Homie',
+      description: 'A short private note to the people who make Homie, and ONLY with the person\'s yes. action "draft" (the default) sends nothing: it shows the note exactly as it would go (a card with Send, Edit and Don\'t send; the words, the step, the studio and plugin versions and the app, after keys, paths, emails and code are taken out), and you show the same text in the chat and ask. action "send" sends that draft (its "draft" id, with the same kind and text) only after the person said yes in their own words; "decline" records their no. OFFER it (offered: true) at most once a session, at a natural moment: after an error you could not fix, when the person sounds confused or frustrated, or at the end of their first studio setup or first publish. Never nag; a no is final for the session. When the person asks to tell Homie something, draft it with offered: false. Write it in plain words from what happened (what they tried, what they expected, what they saw), never a log, a file, code, a key or someone\'s name; a reply address only if they typed it themselves.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          action: str('draft (show it; sends nothing), send (after the person\'s yes) or decline (their no)', { enum: ['draft', 'send', 'decline'] }),
+          kind: str('What it is', { enum: [...FEEDBACK_KINDS] }),
+          text: str(`What happened, in plain words, at most ${FEEDBACK_LIMITS.text.toLocaleString('en-US')} characters: your draft, or the person\'s own words`),
+          step: str('Optional: the step or skill it is about, e.g. "studio-setup: put it online" or "publish"'),
+          email: str('Optional: a reply address, only if the person typed it themselves'),
+          offered: { type: 'boolean', description: 'true when you offered it; false when the person asked to tell Homie' },
+          draft: str('With send or decline: the draft id the draft returned (fd_…)'),
+          by: str('How the person said yes: chat (in their own words), card (the card\'s Send) or dialog (Send in Claude Code\'s own question, which the Homie mod asks)', { enum: ['chat', 'card', 'dialog'] }),
+          studioVersion: str('Filled in here from the studio (the remote Homie MCP takes it from you)'),
+          pluginVersion: str('Filled in here from the plugin (the remote Homie MCP takes it from you)'),
+          app: str('Filled in here from this app (the remote Homie MCP takes it from you)', { enum: [...FEEDBACK_APPS] }),
+          ...STUDIO_ARG,
+        },
+      },
+      annotations: { title: 'Tell Homie', readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }, _meta: ui(UI.feedback),
+      run: async (a) => feedbackTool(ctx, a),
+    },
     {
       name: 'file_list', title: 'List studio files',
       description: 'The files and folders in the studio (or one folder of it), two levels deep. Paths are relative to the studio.',
@@ -1238,4 +1371,4 @@ export function slimCodex(html, { max = 140_000, pictures = true } = {}) {
   return h.length <= max ? h : null;
 }
 
-export const _test = { checklist, feedFor, slimCodex, expandHome };
+export const _test = { checklist, feedFor, slimCodex, expandHome, feedbackFacts };

package/lib/mcp.mjs

@@ -50,10 +50,12 @@ 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" }).
 
+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.`;
 
-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' };
-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' };
+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');
 
 /** One card's whole document: the shared look and bridge, and the card's own script, as the files are. */
@@ -160,6 +162,8 @@ export async function serveMcp({ studios = null, skills = null, cwd = process.cw
       switch (method) {
         case 'initialize': {
           const asked = params?.protocolVersion;
+          // Which app this is (Claude Code, Codex, the Claude desktop app): a note to Homie says so, and nothing more.
+          ctx.client = params?.clientInfo ?? null;
           return reply({
             protocolVersion: PROTOCOLS.includes(asked) ? asked : PROTOCOLS[0],
             capabilities: { tools: { listChanged: true }, resources: { listChanged: false }, prompts: { listChanged: false } },