@homie-rocks/studio 0.27.0 → 0.29.0

package/lib/lounge-cli.mjs

@@ -0,0 +1,70 @@
+/**
+ * `homie-studio lounge` — the studio's Lounge from the studio folder (worker/lounge.mjs says what it is; chat/LOUNGE.md
+ * the whole of it). The office key it uses is `office`'s: minted with the studio's own Cloudflare login, ten minutes
+ * long, dropped as soon as the answer is in.
+ *
+ *   homie-studio lounge                                 its rules, play nights, moderators, last lines and reports
+ *   homie-studio lounge night "<title>" --at <time> [--minutes 120] [--game <id>|<https link>] [--note "…"]
+ *                                                       a play night; --at is an ISO time with its zone, or UTC (…Z)
+ *   homie-studio lounge night remove <id>
+ *   homie-studio lounge history <days>                  keep what is said for that many days (0 keeps nothing)
+ *   homie-studio lounge rules [--slow <s>] [--who anyone|signed-in] [--mode …] [--hub on|off] [--ai on|off] | --reset
+ *   homie-studio lounge mod <player id> [--remove]      a moderator: Remove, Mute, Kick (an hour at most), slow mode
+ *   homie-studio lounge remove <line id>|--all
+ *
+ * Keeping more (a longer history), opening chat up, a new moderator, a mute or a kick are only ASKED for here: the answer
+ * is the owner's one-tap link, as `office kick` gives. A play night, slow mode, taking a message down and keeping less
+ * happen at once.
+ */
+import { askedFor, withKey } from './office.mjs';
+import { chatFields } from './chat-cli.mjs';
+
+export async function loungeShow(root, { url } = {}) {
+  const r = await withKey(root, url, (call) => call('/_studio/api/lounge'));
+  if (!r.ok) return { ok: false, command: 'lounge', why: r.why ?? r.message ?? 'the office did not answer' };
+  return { command: 'lounge', ...r, ok: true };
+}
+
+export async function loungeNight(root, args, flags, { url } = {}) {
+  if (args[0] === 'remove') {
+    if (!/^pn_[a-f0-9]{12}$/.test(String(args[1] ?? ''))) return { ok: false, command: 'lounge night', why: 'usage: homie-studio lounge night remove <id> (the ids are in `homie-studio lounge`)' };
+    const r = await withKey(root, url, (call) => call('/_studio/api/lounge/night', { remove: args[1] }));
+    return r.ok ? { ok: true, command: 'lounge night', message: 'Play night removed.' } : { ok: false, command: 'lounge night', why: r.message ?? r.why };
+  }
+  const title = args.join(' ').trim();
+  if (!title || !flags.get('at')) return { ok: false, command: 'lounge night', why: 'usage: homie-studio lounge night "<title>" --at 2026-10-09T19:00:00-07:00 [--minutes 120] [--game <id>] [--note "…"]' };
+  const body = { title, at: String(flags.get('at')), ...(flags.has('minutes') ? { minutes: Number(flags.get('minutes')) } : {}), ...(flags.has('game') ? { game: String(flags.get('game')) } : {}), ...(flags.has('note') ? { note: String(flags.get('note')) } : {}) };
+  const r = await withKey(root, url, (call) => call('/_studio/api/lounge/night', body));
+  return r.ok ? { ok: true, command: 'lounge night', id: r.id, message: `Play night added (${r.id}): it shows in the Lounge in everyone's own time.` } : { ok: false, command: 'lounge night', why: r.message ?? r.why };
+}
+
+export async function loungeRulesSet(root, flags, { url, history = undefined } = {}) {
+  const body = flags.has('reset') ? { reset: true } : { ...chatFields(flags), ...(history !== undefined ? { history: Math.floor(Number(history)) } : flags.has('history') ? { history: Math.floor(Number(flags.get('history'))) } : {}) };
+  if (!body.reset && !Object.keys(body).length) return { ok: false, command: 'lounge rules', why: 'say what to change: --history <days>, --slow, --who, --mode, --hub, --ai, --block, --allow; or --reset' };
+  const r = await withKey(root, url, (call) => call('/_studio/api/lounge/rules', body));
+  return askedFor(root, url, r, 'lounge rules');
+}
+
+export async function loungeMod(root, player, { url, remove = false } = {}) {
+  if (!/^[A-Za-z0-9_-]{1,64}$/.test(String(player ?? ''))) return { ok: false, command: 'lounge mod', why: 'usage: homie-studio lounge mod <player id> [--remove] (`homie-studio lounge` shows the ids of signed-in senders)' };
+  const r = await withKey(root, url, (call) => call('/_studio/api/lounge/mod', { player, ...(remove ? { remove: true } : {}) }));
+  return askedFor(root, url, r, 'lounge mod');
+}
+
+export async function loungeRemove(root, id, { url, all = false } = {}) {
+  if (!id && !all) return { ok: false, command: 'lounge remove', why: 'usage: homie-studio lounge remove <line id> | --all' };
+  const r = await withKey(root, url, (call) => call('/_studio/api/lounge/remove', all ? { all: true } : { id }));
+  return r.ok ? { ok: true, command: 'lounge remove', message: `Took ${r.removed ?? 0} message${r.removed === 1 ? '' : 's'} down, on every screen.` } : { ok: false, command: 'lounge remove', why: r.message ?? r.why };
+}
+
+export function loungeLines(r) {
+  const L = r.lounge;
+  if (!L) return ['This studio has no Lounge: add "lounge": true to studio.json and deploy.'];
+  const c = L.rules ?? {};
+  const out = [`${L.name} (${L.page}): ${c.mode}${c.mode === 'text' ? `, typing ${c.who}` : ''}, emoji ${c.react}, slow ${c.slow} s, ${c.history ? `kept ${c.history} days` : 'nothing kept'}${c.hub ? ', shown on homie.rocks' : ''}${L.kids ? ', kids' : ''} · rules from ${L.from === 'office' ? 'the office' : 'the defaults'} · ${L.here} here now`];
+  for (const n of L.nights ?? []) out.push(`  night ${n.id}: ${n.title}, ${n.at} for ${n.minutes} min${n.game?.name ? ` (${n.game.name})` : ''}`);
+  for (const m of L.mods ?? []) out.push(`  moderator ${m.player}: ${m.name ?? '?'}`);
+  for (const l of (L.lines ?? []).filter((x) => x.kind !== 'react').slice(-12)) out.push(`  ${l.id}  ${l.by === 'studio' ? 'Studio' : l.name}${l.player ? ` [${l.player}]` : ''}: ${l.card ? `card: ${l.card.title} by ${l.card.studio}` : l.text}`);
+  for (const p of L.reports ?? []) out.push(`  report ${p.id}: "${p.text}" by ${p.name} (${p.reasonText})`);
+  return out;
+}

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,9 +45,12 @@ 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,
 });
 
+/** Homie's own updates by email (0.29.0): the sign-up page on homie.rocks, double opt-in, for the first-run card. */
+export const HOMIE_UPDATES = 'https://homie.rocks/updates/?from=plugin';
 const inside = (base, p) => p === base || p.startsWith(base.endsWith(sep) ? base : `${base}${sep}`);
 const realOr = (p) => { try { return realpathSync(p); } catch { return resolve(p); } };
 
@@ -72,6 +76,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); }
@@ -208,6 +216,9 @@ async function setupCard(ctx, root, { fresh = false, made = null, install = null
     studios, checklist: steps,
     status: { rows: status.rows.map(({ parts, ...r }) => r), features: status.features, next: status.next, meanwhile: status.meanwhile, blocking: status.blocking },
     install: job ? jobView(job) : null, made,
+    // Homie's own updates by email (0.29.0): a link the person opens and signs up at themselves (double opt-in on
+    // homie.rocks). The card never asks for an address, and an agent never types one in for the person.
+    updates: HOMIE_UPDATES,
   };
   const text = [
     current ? `Studio: ${current.name} (${root})${current.installed ? '' : job ? ' (installing its toolkit)' : ''}` : `No studio yet${ctx.studiosDir ? ` in ${ctx.studiosDir}` : ''}.`,
@@ -217,6 +228,7 @@ async function setupCard(ctx, root, { fresh = false, made = null, install = null
     '',
     formatStatus(status),
     '',
+    `Homie updates by email (optional): ${HOMIE_UPDATES} (the person signs up there themselves; never type an address in for them).`,
     'The card on screen shows this; it follows the install by itself.',
   ].join('\n');
   return ok(text, data);
@@ -580,6 +592,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 +1236,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 +1377,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 } },

package/lib/redact.mjs

@@ -0,0 +1,99 @@
+/**
+ * SECRETS OUT OF TOOL OUTPUT. The Homie mod runs every tool result through `redact` before Claude reads it or the
+ * transcript keeps it. It only matches text: it never opens a key file, the keychain or the environment.
+ *
+ * What it hides: the studio's own one-time and owner keys (office and stats keys `hsk_`, progress write keys `hbk_`,
+ * agent passes `hap_…`, whose public id part stays), Cloudflare API tokens and global keys, provider keys (fal,
+ * ElevenLabs, Anthropic, OpenAI, GitHub, npm, Stripe keys and webhook secrets, AWS, Google), bearer tokens, private key blocks, and the value
+ * of any `NAME=value` whose name says key, token or secret.
+ *
+ * A link that carries one (the owner's one-time sign-in link, a confirm link, a player-owner link) is a link for the
+ * person, not for Claude: it is taken out whole and handed back in `links`, so the mod can show it to the person in
+ * its pane, and Claude reads that it is there.
+ */
+
+const HIDE = (kind) => `[${kind} hidden by Homie]`;
+
+/** Each rule: what it is, the pattern, and how to write what replaces a match (the default hides the whole match). */
+export const RULES = [
+  { kind: 'private key', re: /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g },
+  { kind: 'office key', re: /\bhsk_[a-f0-9]{48}\b/g },
+  { kind: 'progress key', re: /\bhbk_[a-f0-9]{48}\b/g },
+  // An agent pass: its id (hap_ and ten hex digits) is public and stays; the secret after it goes.
+  { kind: 'agent pass', re: /\b(hap_[a-f0-9]{10})_[A-Za-z0-9_-]{40}(?![A-Za-z0-9_-])/g, to: (m, id) => `${id}_${HIDE('agent pass')}` },
+  { kind: 'Anthropic key', re: /\bsk-ant-[A-Za-z0-9_-]{20,}/g },
+  { kind: 'OpenAI key', re: /\bsk-(?:proj-|svcacct-|admin-)?[A-Za-z0-9_-]{32,}/g },
+  { kind: 'ElevenLabs key', re: /\bsk_[a-f0-9]{48}\b/g },
+  { kind: 'Stripe key', re: /\b(?:sk|rk)_(?:live|test)_[A-Za-z0-9]{16,}\b/g },
+  // A webhook signing secret has no live/test part: whsec_ and the secret itself.
+  { kind: 'Stripe webhook secret', re: /\bwhsec_[A-Za-z0-9+/=_-]{16,}/g },
+  { kind: 'fal key', re: /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}:[0-9a-f]{32}\b/g },
+  { kind: 'GitHub token', re: /\b(?:gh[pousr]_[A-Za-z0-9]{36,}|github_pat_[A-Za-z0-9_]{40,})\b/g },
+  { kind: 'npm token', re: /\bnpm_[A-Za-z0-9]{36}\b/g },
+  { kind: 'AWS key', re: /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g },
+  { kind: 'Google key', re: /\bAIza[0-9A-Za-z_-]{35}\b/g },
+  { kind: 'Cloudflare key', re: /(X-Auth-Key["']?\s*[:=]\s*["']?)([a-f0-9]{37})\b/gi, to: (m, head) => `${head}${HIDE('Cloudflare key')}` },
+  { kind: 'token', re: /(\b[Bb]earer\s+)([A-Za-z0-9_\-.~+/]{24,}=*)/g, to: (m, head) => `${head}${HIDE('token')}` },
+  // NAME=value (or NAME: value) where the name says what it is: CLOUDFLARE_API_TOKEN, FAL_KEY, ELEVENLABS_API_KEY ...
+  // Only a value that looks like a key (16+ characters of letters AND digits, no dots or brackets), so source code
+  // that names a key (`const FAL_KEY = process.env.FAL_KEY`) is never changed under Claude's eyes.
+  {
+    kind: 'secret',
+    re: /\b([A-Z][A-Z0-9_]*(?:API_KEY|API_TOKEN|_TOKEN|_SECRET|SECRET_KEY|_KEY|PASSWORD)\b["']?\s*[=:]\s*["']?)([A-Za-z0-9_\-+/=:]{16,})(?![A-Za-z0-9_.(])/g,
+    to: (m, head, value) => (/[A-Za-z]/.test(value) && /[0-9]/.test(value) ? `${head}${HIDE('secret')}` : m),
+  },
+];
+
+const URL_RE = /https?:\/\/[^\s"'<>`)\]]+/g;
+const LINK_SECRET = /\b(?:hsk|hbk)_[a-f0-9]{48}\b|\bhap_[a-f0-9]{10}_[A-Za-z0-9_-]{40}/;
+export const LINK_NOTE = '[one-time owner link: the Homie mod showed it to the person in its Studio pane; Claude never sees it]';
+
+/** Redact one string: { text, hits: [kinds], links: [urls] }. Unchanged text keeps its identity. */
+export function redactText(text) {
+  if (typeof text !== 'string' || text.length < 8) return { text, hits: [], links: [] };
+  const hits = [];
+  const links = [];
+  let out = text.replace(URL_RE, (url) => {
+    if (!LINK_SECRET.test(url)) return url;
+    links.push(url.replace(/[.,;:]+$/, ''));
+    hits.push('owner link');
+    return LINK_NOTE + url.slice(url.replace(/[.,;:]+$/, '').length);
+  });
+  for (const rule of RULES) {
+    rule.re.lastIndex = 0;
+    out = out.replace(rule.re, (...m) => {
+      const replaced = rule.to ? rule.to(...m) : HIDE(rule.kind);
+      if (replaced !== m[0]) hits.push(rule.kind);
+      return replaced;
+    });
+  }
+  return hits.length ? { text: out, hits, links } : { text, hits, links };
+}
+
+/**
+ * Redact every string inside a value (a tool's result record, an MCP result, a string), at most 12 levels deep.
+ * Returns { value, hits, links }; `value` is the same object when nothing was hidden.
+ */
+export function redact(value) {
+  const hits = [];
+  const links = [];
+  const walk = (v, depth) => {
+    if (typeof v === 'string') {
+      const r = redactText(v);
+      if (r.hits.length) { hits.push(...r.hits); links.push(...r.links); }
+      return r.text;
+    }
+    if (depth > 12 || v === null || typeof v !== 'object') return v;
+    if (Array.isArray(v)) {
+      let changed = false;
+      const next = v.map((x) => { const y = walk(x, depth + 1); if (y !== x) changed = true; return y; });
+      return changed ? next : v;
+    }
+    let changed = false;
+    const next = {};
+    for (const [k, x] of Object.entries(v)) { const y = walk(x, depth + 1); if (y !== x) changed = true; next[k] = y; }
+    return changed ? next : v;
+  };
+  const out = walk(value, 0);
+  return { value: out, hits: [...new Set(hits)], links: [...new Set(links)] };
+}

package/lib/scaffold.mjs

@@ -30,6 +30,7 @@ import { OFFICE_MIGRATION, OFFICE_MIGRATION_FILE } from '../worker/office-schema
 import { SERVERS_MIGRATION, SERVERS_MIGRATION_FILE } from '../worker/servers.mjs';
 import { CHAT_MIGRATION, CHAT_MIGRATION_FILE } from '../worker/chat-store.mjs';
 import { SHOP_MIGRATION, SHOP_MIGRATION_FILE } from '../worker/shop-store.mjs';
+import { LOUNGE_MIGRATION, LOUNGE_MIGRATION_FILE } from '../worker/lounge-store.mjs';
 import { themeFile } from './site.mjs';
 
 export const COMPAT_DATE = '2026-06-01';
@@ -427,6 +428,18 @@ chat's card follows the work from then on) and, for a studio still being set up,
   the budget until the person says Proceed, and takes keys out of command output. When it refuses a call, say what
   you meant to do and why; do not retry it unless the person asks.
 
+## Telling Homie
+
+The people who make Homie read every note, and someone who is stuck rarely writes to a forum. So 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 in a session, to send them a short note about it: the Homie MCP's \`homie_feedback\`
+(in Claude Code also \`/feedback\`, and Tell Homie in the Studio pane). Draft it in plain words from what happened
+(what they tried, what they expected, what they saw); a draft sends nothing. Show it exactly as it would go, and send
+it only after they say yes (in Claude Code, Claude Code itself asks them with the exact note). Never nag: a no is
+final for the session, and help never depends on it. Never put a key, a log, a file, code or anyone's name in a
+note; a reply address only if they typed it. When they ask to tell Homie something, draft it with
+\`offered: false\`.
+
 ## Beta
 
 Homie for studios is in beta. When something breaks, or a game you want to port does
@@ -640,6 +653,7 @@ export { default, Table, Lobby } from '@homie-rocks/studio/worker';
     [`site/migrations/${SERVERS_MIGRATION_FILE}`]: SERVERS_MIGRATION,
     [`site/migrations/${CHAT_MIGRATION_FILE}`]: CHAT_MIGRATION,
     [`site/migrations/${SHOP_MIGRATION_FILE}`]: SHOP_MIGRATION,
+    [`site/migrations/${LOUNGE_MIGRATION_FILE}`]: LOUNGE_MIGRATION,
     'wrangler.jsonc': wranglerConfig({ worker, name, d1: studio.cloudflare.d1, r2: studio.cloudflare.r2, layout: 'root' }),
     '.claude/skills/.gitkeep': '',
   };
@@ -754,13 +768,22 @@ function ensureChatMigration(root) {
   return `site/migrations/${CHAT_MIGRATION_FILE}`;
 }
 
+/** A studio made before 0.29.0 has no Lounge tables: kept chat (only when an owner turns history on), play nights, moderators. */
+function ensureLoungeMigration(root) {
+  const file = join(root, 'site', 'migrations', LOUNGE_MIGRATION_FILE);
+  if (existsSync(file)) return null;
+  mkdirSync(dirname(file), { recursive: true });
+  writeFileSync(file, LOUNGE_MIGRATION);
+  return `site/migrations/${LOUNGE_MIGRATION_FILE}`;
+}
+
 export function ensureMigrations(root) {
-  return [ensureStatsMigration(root), ensurePlayersMigration(root), ensureOfficeMigration(root), ensureServersMigration(root), ensureChatMigration(root), ensureShopMigration(root)].filter(Boolean);
+  return [ensureStatsMigration(root), ensurePlayersMigration(root), ensureOfficeMigration(root), ensureServersMigration(root), ensureChatMigration(root), ensureShopMigration(root), ensureLoungeMigration(root)].filter(Boolean);
 }
 
 /** What a migration file the template added is for, in a few words (deploy and dev say it). */
 export function migrationWord(file) {
-  return /shop/.test(file) ? 'the shop: orders, what players own, refunds and referral books (it sells nothing until shop.json and the owner\'s Stripe key are in)' : /players/.test(file) ? 'player accounts and cloud saves' : /chat/.test(file) ? 'room chat: the owner\'s chat rules and players\' reports (never the chat itself)' : /servers/.test(file) ? 'servers and agent seats: room pools with their own rules, AI passes' : /office/.test(file) ? 'the back office: launch states, invites, the owner\'s controls' : 'the studio\'s own stats: counts, never tracks';
+  return /lounge/.test(file) ? 'the Lounge and kept chat: play nights, moderators, and what was said only where an owner turns history on' : /shop/.test(file) ? 'the shop: orders, what players own, refunds and referral books (it sells nothing until shop.json and the owner\'s Stripe key are in)' : /players/.test(file) ? 'player accounts and cloud saves' : /chat/.test(file) ? 'room chat: the owner\'s chat rules and players\' reports (never the chat itself)' : /servers/.test(file) ? 'servers and agent seats: room pools with their own rules, AI passes' : /office/.test(file) ? 'the back office: launch states, invites, the owner\'s controls' : 'the studio\'s own stats: counts, never tracks';
 }
 
 /**

package/lib/template-history.json

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

package/mcp/ui/card.css

@@ -92,3 +92,11 @@ details summary{cursor:pointer;color:var(--c-fg2);font-size:13px;margin-top:10px
 .clips{display:grid;grid-template-columns:repeat(auto-fill,minmax(104px,1fr));gap:8px}
 .clip{display:grid;gap:3px;align-content:start;padding:6px;border-radius:var(--r-sm);background:var(--c-bg)}.clip .art{aspect-ratio:1;border-radius:var(--r-sm);background:var(--c-bg3);display:grid;place-items:center;overflow:hidden;color:var(--c-fg3);font-size:20px}.clip .art img{width:100%;height:100%;object-fit:cover}
 .clip b{font-size:13px}.clip span{font-size:11.5px;color:var(--c-fg2);overflow-wrap:anywhere}.clip.missing{opacity:.8;box-shadow:inset 0 0 0 1px var(--c-line2)}.clip button{justify-self:start}
+/* Tell Homie (feedback.js): the note as it would go, and the editor that rewords it. */
+.quote{margin:8px 0 0;padding:12px 14px;border-radius:var(--r-md);background:var(--c-bg2);border-left:3px solid var(--accent);font:15px/1.5 var(--f-sans);color:var(--c-fg);white-space:normal;overflow-wrap:anywhere}
+.kinds{display:flex;flex-wrap:wrap;gap:6px;margin:4px 0 10px}
+textarea{display:block;width:100%;min-height:110px;resize:vertical;font:15px/1.45 var(--f-sans);padding:10px 12px;border-radius:var(--r-md);border:1px solid var(--c-line2);background:var(--c-bg);color:var(--c-fg)}
+input[type=email]{display:block;width:100%;margin:8px 0 12px;font:14px/1.2 var(--f-sans);padding:9px 10px;border-radius:var(--r-sm);border:1px solid var(--c-line2);background:var(--c-bg);color:var(--c-fg)}
+textarea:focus-visible,input[type=email]:focus-visible{outline:2px solid var(--c-fg);outline-offset:1px}
+.actions.send{margin-top:14px}
+@media (max-width:420px){.actions.send button{flex:1 1 auto}}