@homie-rocks/studio 0.27.0 → 0.29.0

package/CHANGELOG.md

@@ -17,9 +17,67 @@ 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.29.0] - 2026-10-03
+
+**Plugin 0.30.0** · [#44](https://github.com/homie-rocks/homie/pull/44)
+
+The Lounge: a community room on your own studio, with play nights, moderators, live rooms and "show what you made" cards, and chat history you can turn on.
+
+### Added
+
+- The Lounge. `"lounge": true` in studio.json gives your studio a community room at `/lounge/`, in your studio's own look: one column of talk on a phone with "What's on" a tap away, the talk beside a sidebar on a computer. It is room chat in a room of its own, on your own Cloudflare: reactions and quick lines for anyone, typing for players signed in with a passkey (Sign in and Make a passkey are on the page itself), and every typed line through the word list and your Workers AI review (Clef) before anyone sees it. Slow mode is 3 s to start with. `chat/LOUNGE.md` has the whole of it.
+- Play nights. Set them in the office (a name, a time in your own zone, how long, a game) or with `homie-studio lounge night "<title>" --at <time>`. Everyone sees the time in their own zone, a countdown, "On now", the game's Play, and Add to calendar (a small `.ics` the browser makes).
+- Live rooms in the Lounge, each with Watch and Join: your studio's own, and with a directory the busiest across it (`"featured": "studio"` keeps it to yours, `"none"` shows none).
+- Show what you made. A signed-in person pastes a link to a game and it becomes a card with the game's own title, pitch, picture and a Play button. Only a Homie studio's game can be one (yours, or a site that answers the studio manifest), its words pass the word list and the review like a typed line, and each person posts three an hour. Typed links stay held.
+- Moderators. Name a player account as a moderator from one of their lines in the office (or `homie-studio lounge mod <player id>`): from the Lounge page they take a line down, mute or kick its sender for up to an hour (their lines come down with them) and set slow mode, never on your lines or another moderator's. You have the same from the page, for up to a day, and everything else in the office's new Lounge section: its rules, play nights, moderators, last lines and reports.
+- Chat history you can turn on (`history`, a number of days, 1 to 90). In the office, "Keep what is said" for the Lounge, or `homie-studio lounge history <days>`; for a game, `"chat": { "history": 7 }` or the office. What is kept, in your studio's own D1: typed lines, quick lines, cards and your own studio lines, the name shown, when, and for a signed-in sender their account id. Never a reaction, an address or a browser key. It is deleted after that many days; keeping fewer days (or none) deletes the rest at once. The room gives kept lines back when it opens ("Earlier messages" pages further), a report still finds an older line, and a mute or kick from a kept line holds its sender's account.
+- Anyone takes their own message down: Delete on their own line in the Lounge (a signed-in person's kept lines too, a guest's while it is in the room's last minutes). Deleting an account at `/account/` deletes every line it kept, and the account's download has them.
+- `homie-studio lounge` (rules, play nights, moderators, last lines, reports), `lounge night`, `lounge history`, `lounge rules`, `lounge mod` and `lounge remove`. From your AI's office key, keeping more days, opening chat up, a new moderator, a mute or a kick only ASK (your one tap); a play night, slow mode, taking a line down and keeping less happen at once.
+- `/lounge/api/now`: the Lounge's public facts (its rules, play nights and live rooms) as JSON, and the studio's manifest names its Lounge. homie.rocks can show a Lounge live when its rules allow it (`hub`): a visitor's own browser opens the Lounge's socket, as for a room's card; they react there and type on your site. The sitemap and llms.txt list the Lounge's page; robots.txt keeps its socket and APIs out.
+- "Get Homie updates" on the setup card (Claude, Claude Desktop and the Claude Code mod): a link to homie.rocks's own sign-up for a short email when Homie ships something. The person signs up there themselves (double opt-in); the card never asks for an address.
+
+### Changed
+
+- Room chat's rules have one more field, `history`. It is 0 for every game and for the Lounge until an owner turns it on, and always 0 on a kids server, a beginner server and a kids Lounge, so nothing changes for a studio that does nothing: a room still keeps the last 50 lines of the last 15 minutes in memory and nothing else.
+- A line on the wire may carry `card`, `mod`, `kept` and, on a page's own copy, `mine`; a page that knows none of them shows the line's words. A watching page may send `unsay` for its own line. The room's facts count watching pages (`counts.shells`). The relay stays revision 8.
+
+### Upgrade notes
+
+- `homie-studio upgrade` adds migration `0009_studio_lounge.sql` (kept chat, play nights, moderators; all empty until you use them) and `npm run deploy` applies it. Nothing else changes until you add `"lounge": true` to studio.json and deploy. A game already called `lounge` keeps its page, and the build says the Lounge is off.
+- Before you turn history on, read `chat/OWNERS.md`: it says what is kept and what that means for children's data. The Lounge's page tells people what is kept, in its "How it works".
+
+## [0.28.0] - 2026-10-03
+
+**Plugin 0.29.0** · [#43](https://github.com/homie-rocks/homie/pull/43) · [release-2026-10-03-studio-0.28.0](https://github.com/homie-rocks/homie/releases/tag/release-2026-10-03-studio-0.28.0)
+
+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)
+**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.
 

package/README.md

@@ -27,6 +27,7 @@ npx homie-studio stats                                 # the studio's own number
 npx homie-studio office                                 # who is playing now, in every live room (the back office)
 npx homie-studio servers                                # each game's servers: humans-only, hybrid AI seats, beginner guides
 npx homie-studio chat                                   # room chat: each game's rules, the rooms' last minutes, reports
+npx homie-studio lounge                                 # the studio's Lounge: play nights, moderators, kept chat
 npx homie-studio upgrade                               # what a newer template adds to this studio (--apply to take it)
 ```
 
@@ -49,6 +50,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>:
@@ -345,10 +354,38 @@ npx homie-studio chat words                                             # the bu
   lines taken down), the same in the owner's own game, the reports players make, and Announce (a studio line).
 - **Speech bubbles:** `net.on('say')` and the port kit's `createBubbles` / `paintBubbles`; Gem Rush, Ember Vale and
   Gem Rush 3D draw them over the speaker.
-- **Nothing is stored** but a report (the one message, 30 days): the room keeps 15 minutes in memory.
+- **Nothing is stored** but a report (the one message, 30 days): the room keeps 15 minutes in memory. An owner may
+  turn a room's `history` on (0.29.0, a number of days; off for every game, never on a kids server): then what was
+  said (never a reaction) is kept in the studio's own D1 for that long, and people take their own lines down.
   [chat/CHAT.md](chat/CHAT.md) is the short version and why Clef; [chat/OWNERS.md](chat/OWNERS.md) a plain note for
   studio owners on chat and children's data; NETPLAY.md section 19 the wire.
 
+## The Lounge: a room for the studio's community
+
+`"lounge": true` in studio.json gives the studio a community room at `/lounge/` (0.29.0): room chat in a lasting room
+of its own, on the studio's own Cloudflare like everything else. Reactions and quick lines for anyone, typing for
+players signed in with a passkey (signing in is on the page), every typed line through the word list and the Clef
+review first.
+
+```sh
+npx homie-studio lounge                                                 # its rules, play nights, moderators, lines, reports
+npx homie-studio lounge night "Night Rush night" --at 2026-10-09T19:00:00-07:00 --game night-rush
+npx homie-studio lounge history 14                                      # keep what is said for 14 days (asked: the owner confirms)
+npx homie-studio lounge mod <player id>                                 # a moderator (asked)
+```
+
+- **Play nights** the owner sets in the office: everyone sees the time in their own zone, a countdown and Add to
+  calendar. **Live rooms** with Watch and Join: the studio's, and with a directory the busiest across it.
+- **Show what you made:** a signed-in person pastes a link to a Homie studio's game and it becomes a card with the
+  game's own title, pitch and picture (read from that studio's manifest; its words pass the word list and the
+  review). Typed links stay held.
+- **Keeping it kind:** anyone reports a line or takes their own down; moderators the owner names Remove, Mute and
+  Kick (an hour at most) and set slow mode from the page; the owner has all of it and the office. A kids Lounge
+  keeps to emoji and quick lines and keeps nothing.
+- **History is off** until the owner turns it on (1 to 90 days), and the page says what is kept.
+- **homie.rocks** can show a Lounge live when its rules allow (`hub`): the visitor's browser opens the Lounge's own
+  socket, as for a room's card; they react there and type here. [chat/LOUNGE.md](chat/LOUNGE.md) has the whole of it.
+
 ## Selling things: the shop
 
 A studio sells items for its games (0.24.0; Stripe's own agent tools since 0.24.3) with **its own Stripe account**: the studio is the seller, money goes
@@ -785,7 +822,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/bin/homie-studio.mjs

@@ -106,6 +106,11 @@
  *                                          minutes, players' reports, the review's day; chat rules <game> [--server <id>]
  *                                          --mode off|emoji|lines|text --who anyone|signed-in|members … | --reset;
  *                                          chat remove <game> <room> <line id>; chat budget <neurons>; chat words
+ *   homie-studio lounge                   the studio's Lounge (studio.json "lounge", chat/LOUNGE.md): its rules, play
+ *                                          nights, moderators, last lines and reports; lounge night "<title>" --at <time>
+ *                                          [--minutes 120] [--game <id>]; lounge night remove <id>; lounge history <days>;
+ *                                          lounge rules [--slow <s>] [--who …] | --reset; lounge mod <player> [--remove];
+ *                                          lounge remove <line id> | --all
  *   homie-studio servers [--game <id>]    every server of every game (worker/servers.mjs): its policy, door, the AI's
  *                                          level, live rooms and AI, members, and builds that predate servers
  *   homie-studio servers new <game> "<Name>" --policy open|humans-only|hybrid|beginner [--ai <n>] [--guides <n>]
@@ -258,6 +263,7 @@ import { statsKey, statsLink, statsRevoke, statsShare, statsShow } from '../lib/
 import { playersOwner, playersShow } from '../lib/players.mjs';
 import { officeAnnounce, officeClose, officeInvite, officeKey, officeKick, officeLaunch, officeLines, officeLink, officeMute, officeRevoke, officeShow } from '../lib/office.mjs';
 import { chatBudget, chatLines, chatRemove, chatRulesSet, chatShow, chatWords } from '../lib/chat-cli.mjs';
+import { loungeLines, loungeMod, loungeNight, loungeRemove, loungeRulesSet, loungeShow } from '../lib/lounge-cli.mjs';
 import { detectLocalAi, localAiVars } from '../lib/local-ai.mjs';
 import { agentsBrain, agentsBrainKey, agentsPass, agentsPasses, agentsRevoke, agentsTry, serversClose, serversLevel, serversLines, serversList, serversMember, serversNew, serversSet } from '../lib/servers.mjs';
 import { AgentSeat } from '../lib/agent-seat.mjs';
@@ -479,8 +485,13 @@ function print(result) {
       lines.push(result.note);
       break;
     case 'chat remove':
+    case 'lounge night':
+    case 'lounge remove':
       lines.push(result.message);
       break;
+    case 'lounge':
+      lines.push(...loungeLines(result));
+      break;
     case 'shop':
     case 'shop orders':
     case 'shop check':
@@ -498,6 +509,8 @@ function print(result) {
       break;
     case 'chat rules':
     case 'chat budget':
+    case 'lounge rules':
+    case 'lounge mod':
     case 'shop refund':
       lines.push(result.asked ? `Asked: ${result.what}` : result.message, ...(result.asked ? [`Owner's one-tap link (until the ask ends, 15 min): ${result.link}`, result.use] : []));
       break;
@@ -791,6 +804,17 @@ async function main() {
     if (sub === 'close') return officeClose(root, positional[2], positional[3], { url, minutes: flags.get('minutes'), reopen: flags.has('reopen') });
     if (sub === 'revoke') return officeRevoke(root, { url });
   }
+  if (cmd === 'lounge') {
+    // The Lounge (0.29.0, chat/LOUNGE.md): its rules and history, play nights, moderators, lines.
+    const url = flags.get('url');
+    if (!sub) return loungeShow(root, { url });
+    if (sub === 'night') return loungeNight(root, positional.slice(2), flags, { url });
+    if (sub === 'history') return loungeRulesSet(root, flags, { url, history: positional[2] });
+    if (sub === 'rules') return loungeRulesSet(root, flags, { url });
+    if (sub === 'mod') return loungeMod(root, positional[2], { url, remove: flags.has('remove') });
+    if (sub === 'remove') return loungeRemove(root, positional[2], { url, all: flags.has('all') });
+    return { ok: false, command: 'lounge', why: `unknown: lounge ${sub} (night, history, rules, mod, remove)` };
+  }
   if (cmd === 'chat') {
     // Room chat (0.23.0, NETPLAY.md section 19): rules, the room's last minutes, reports, the review's budget.
     const url = flags.get('url');

package/chat/CHAT.md

@@ -48,11 +48,15 @@ studio's owner is responsible for, read [OWNERS.md](OWNERS.md).
 | `links`, `swears` | `block` or `allow` (a link is never clickable; slurs, sexual words, threats and contact details are always held) | `block` |
 | `ai` | review typed messages with the studio's own Workers AI | `true` |
 | `bubbles`, `watchers`, `hub` | over the speaker's character; watchers may send; homie.rocks may show it | `true` |
+| `history` | days to keep what is said (typed lines, quick lines, cards; never a reaction) in the studio's own D1, 0 to 90 (0.29.0; never on a kids server) | `0`: nothing past the room's few minutes |
 | `emoji`, `lines` | up to 3 more reactions; up to 12 quick lines (each passes the chat floor at build) | the five; 8 friendly lines |
 | `block`, `allow` | the studio's own words to hold (`word*` inside words) or to let through | none |
 
 `"chat": false` turns it off. A kids server, and every beginner server, keeps chat to emoji and
-quick lines whatever the game says.
+quick lines whatever the game says, and keeps nothing.
+
+**A room for the studio's community** is the Lounge (0.29.0): room chat at `/lounge/` with play nights, moderators,
+live rooms, "show what you made" cards and history the owner can turn on. Read [LOUNGE.md](LOUNGE.md).
 
 **Where it sits on the screen, in game.json `"screen"`**, so a game with a busy HUD keeps typed
 chat without anything covering its clock, its title or its controls. The Chat pill sits in the

package/chat/LOUNGE.md

@@ -0,0 +1,114 @@
+# The Lounge
+
+A studio's own community room, at `/lounge/` on the studio's site (`@homie-rocks/studio` 0.29.0): play nights,
+demos, "show what you made", and talking with the people who play your games. It runs on your own Cloudflare
+account like everything else in the studio. Nobody else hosts it, reads it or moderates it for you.
+
+It is room chat ([CHAT.md](CHAT.md), [NETPLAY.md section 19](../netplay/NETPLAY.md)) in a room of its own: the same
+reactions floating up every screen, quick lines, typing for signed-in players, the same word list and Clef review
+before anyone sees a typed line, and the same owner's tools. On top of that it has what a lasting room needs:
+history (only if you turn it on), moderators, play nights, live rooms to jump into, and cards for games people made.
+
+## Turn it on
+
+In `studio.json`:
+
+```json
+"lounge": true
+```
+
+or, to say more:
+
+```json
+"lounge": {
+  "name": "The Lounge",
+  "blurb": "Play nights, demos and what everybody is making. Come and say hi.",
+  "featured": "directory",
+  "kids": false,
+  "chat": { "slow": 5 }
+}
+```
+
+| Field | | Default |
+|---|---|---|
+| `name`, `tab` | the page's title, and the word in the site's top line | "The Lounge", "Lounge" |
+| `blurb` | one line under the title | the line above |
+| `featured` | live rooms in the sidebar: `directory` (yours, then the busiest across your directory), `studio` (yours only), `none` | `directory` |
+| `kids` | emoji and quick lines only, nothing kept | `true` for a studio with `"audience": "kids"` |
+| `chat` | the Lounge's chat rules before you change them in the office (the fields of game.json `chat`) | below |
+
+Then `npm run build` and `npm run deploy` (it applies migration `0009_studio_lounge.sql`). A game already called
+`lounge` keeps its page, and the build says the Lounge is off.
+
+## What it does, with no work
+
+- **The talk.** Reactions and quick lines for anyone; typing for players signed in with a passkey (no password, no
+  email). Every typed line passes the word list and your Workers AI review first. Slow mode is 3 s by default.
+- **Sign in in place.** "Sign in" and "Make a passkey" are on the Lounge page itself; the account is the same one your
+  games and `/account/` use.
+- **Show what you made.** A signed-in person pastes a link to a game. If it is a Homie studio's game (yours, or any
+  site answering `/.well-known/homie-studio.json`), it becomes a card with the game's own title, pitch and picture, and
+  a Play button. Its words pass the word list and the review like a typed line. Three cards an hour each. Plain links
+  are never allowed in typed lines, so a card is the only way a link gets in.
+- **Play nights.** You set them in the office (or with `homie-studio lounge night`). Everyone sees the time in their
+  own zone, a countdown, "On now", the game's link, and Add to calendar (a small `.ics` the browser makes; nothing
+  else is contacted).
+- **Live now.** Your live rooms, and with a directory the busiest rooms across it, each with Watch and Join.
+- **On a phone** it is one column of talk with "What's on" a tap away; on a computer, the talk and a sidebar.
+- **On homie.rocks** (when your rules let it, `hub`), a visitor's own browser opens the Lounge's socket and shows it
+  live, like a room's card there. Those visitors react and send quick lines; typing stays on your site, where they can
+  sign in. homie.rocks keeps none of it.
+
+## Keeping it kind
+
+| Who | Can |
+|---|---|
+| Anyone | react, send quick lines, report a line (the studio sees the line and the reason, never who reported it), take their own line down |
+| Signed in | type, show what they made, take down their own lines, kept ones too |
+| A moderator | take any line down, mute or kick its sender for up to an hour (their lines come down with them), set slow mode; never on your lines or another moderator's |
+| You, the owner | all of that, holds of up to a day, every rule, history, play nights, moderators, from the Lounge itself or the office |
+
+Make someone a moderator from one of their lines in the office ("Make moderator"), or with
+`homie-studio lounge mod <player id>`. A moderator needs an account with a passkey.
+
+**Kids.** A kids Lounge keeps chat to emoji and quick lines and keeps nothing, whatever else it says. Nobody in the
+Lounge is ever asked their age, where they live or for photos; the page says so, and the review holds it.
+
+## History: what is kept, and only if you say so
+
+By default the Lounge keeps what a room keeps: the last 50 lines of the last few minutes, in memory, and nothing
+else. You can choose to keep what is said for 1 to 90 days (the office, or `homie-studio lounge history <days>`).
+Then, in your D1 (`chat_history`):
+
+- typed lines, quick lines, cards and your own studio lines; **never a reaction, an address or a browser key**;
+- the name shown, when, and for a signed-in sender their account id (so they can take their lines down, and deleting
+  their account deletes them);
+- deleted after that many days. Keeping fewer days (or none) deletes the rest at once.
+
+A person sees what is kept on the page ("What's said is kept for 14 days"), takes their own lines down any time,
+downloads theirs with everything else at `/account/`, and deletes them with their account. Reports stay as before:
+one line, 30 days.
+
+History is a room chat rule (`history`, in days), so a game can keep its chat too, but it is **off for every game**
+and stays off unless you turn it on in the office for that game. Turning it on is the owner's one tap when your AI
+asks for it.
+
+## From the studio folder
+
+```sh
+npx --no-install homie-studio lounge                      # rules, play nights, moderators, last lines, reports
+npx --no-install homie-studio lounge night "Night Rush night" --at 2026-10-09T19:00:00-07:00 --minutes 120 --game night-rush
+npx --no-install homie-studio lounge night remove pn_0123456789ab
+npx --no-install homie-studio lounge history 14            # asked: the owner confirms with one tap
+npx --no-install homie-studio lounge rules --slow 10
+npx --no-install homie-studio lounge mod pl_… [--remove]   # asked
+npx --no-install homie-studio lounge remove <line id>
+```
+
+The Lounge's public facts are at `/lounge/api/now` (its rules, play nights and live rooms; homie.rocks reads it).
+
+## What it costs
+
+A line or a reaction is one message on the Lounge's room (Durable Objects, billed 20:1); the fan-out is free. Typed
+lines and cards use the review's daily budget, shared with your rooms (2,000 neurons a day by default, inside
+Workers AI's free 10,000). History is a few D1 rows a line.

package/chat/OWNERS.md

@@ -41,7 +41,9 @@ What that means in practice:
 
 | What | Where | How long |
 |---|---|---|
-| The chat itself (every message and reaction) | Only in the room's memory, on your Cloudflare account | The last 50 messages of the last 15 minutes, for someone who just opened the room. **Never written to storage.** An empty room forgets them a minute after the last person leaves. |
+| The chat itself (every message and reaction) | Only in the room's memory, on your Cloudflare account | The last 50 messages of the last 15 minutes, for someone who just opened the room. **Never written to storage** unless you turn history on (below). An empty room forgets them a minute after the last person leaves. |
+| **Kept chat**, only where you turn `history` on (off for every game and for the Lounge until you choose; never on a kids server) | Your D1 (`chat_history`) | Typed lines, quick lines, cards and your own lines (never a reaction, an address or a browser key): the words, the name shown, when, and for a signed-in sender their account id. For the number of days you chose (1 to 90), then deleted; choosing fewer days deletes the rest at once. A person takes their own lines down, downloads them at `/account/`, and deleting their account deletes them. |
+| The Lounge's play nights and moderators | Your D1 (`lounge_nights`, `lounge_mods`) | A night until a day after it ends; a moderator (their account id) until you remove them. |
 | Who said what | The same memory, for your office's Mute and Kick | As long as the message is in that memory. Never an IP address. |
 | A **report** | Your D1 (`chat_reports`) | The one message reported (its words, its sender's name and account id if they had one, the room, when, the reason picked), for **30 days** or until you dismiss it. Never who reported it. |
 | Your chat rules and your words | Your D1 (`chat_rules`) | Until you change them. |
@@ -63,7 +65,9 @@ or that are directed at children. A typed message can contain personal informati
   child types anything, and there is nothing personal in your chat to keep or lose.
 - **Typing for signed-in players only** (the default) means a person behind each typed line has an
   account you can act on.
-- **Little is stored**, and only briefly (see above). Reports are the exception, kept 30 days.
+- **Little is stored**, and only briefly (see above). Reports are the exception, kept 30 days, and kept chat when
+  you turn history on (never on a kids server or a kids Lounge). If you keep chat, say so where people talk (the
+  Lounge does, on its page) and keep it as short as is useful.
 - **You can delete**: a report with Dismiss, a message with Remove, a player's whole account in
   their own account page (or `players` in the office).
 

package/lib/build.mjs

@@ -53,6 +53,7 @@ import { screenChatProblems } from '../worker/chat-page.mjs';
 import { vocabularyOf } from '../worker/brain.mjs';
 import { shopForBuild } from './shop.mjs';
 import { audienceOf } from '../worker/shop-rules.mjs';
+import { loungeConfig, loungeProblems } from '../worker/lounge-store.mjs';
 
 const SOURCE_SKIP = new Set(['node_modules', 'dist', '.git', '.wrangler', '.port']);
 /** Never copied into a static game's served folder. */
@@ -456,6 +457,9 @@ export async function build(root, { only = null, log = () => {}, deploy = proces
   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 });
+  // The Lounge (0.29.0): studio.json "lounge", checked; off when a game already has /lounge/.
+  for (const p of loungeProblems(studio, rows, chatProblems)) log(`warning: studio.json: ${p}`);
+  const lounge = loungeConfig(studio, rows, { audience: audienceOf(studio) });
   const catalogue = {
     studio: {
       name: studio.name, slug: studio.slug, version: STUDIO_VERSION,
@@ -481,6 +485,7 @@ export async function build(root, { only = null, log = () => {}, deploy = proces
       // (this studio takes no referral statements as a referrer).
       ...(audienceOf(studio) !== 'general' ? { audience: audienceOf(studio) } : {}),
       ...(studio.referrals === false ? { referrals: false } : {}),
+      ...(lounge ? { lounge } : {}),
       build: buildInfo(root),
     },
     games: rows,

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';
+}