@homie-rocks/studio 0.22.0 → 0.23.0

package/CHANGELOG.md

@@ -17,9 +17,38 @@ 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.23.0] - 2026-10-03
+
+**Plugin 0.24.0** · [#33](https://github.com/homie-rocks/homie/pull/33)
+
+Room chat in every game: reactions that float up every screen, quick lines, typing where the rules allow, speech bubbles over characters, rules per game and server, moderation in your own Worker, and the owner's tools.
+
+### Added
+
+- Room chat on every game's play page, with no game code: a Chat pill beside the room button (the corner `screen.share` keeps clear of the game's HUD) and its sheet: the room's last minutes, the five reactions (fire, clap, laugh, heart, wow, in homie.rocks's order, plus up to three of the game's own), the game's quick lines, typing where the rules allow it (and why not where they do not), and Report on a line. New lines show for a moment where the status chip sits (game.json `"screen": { "chat": … }` moves them).
+- Reactions float up every screen in the room, as on the television: the players', the watchers' and the big screen's (at most six a second, eighteen at once). The big screen (`/<game>/tv`) shows the room's lines in a corner, and the watch page has a Chat button and panel. Measured in Chrome with four browsers in one room: a reaction is on the other screens within about 15 ms of the press locally.
+- Speech bubbles over characters: the port kit's `createBubbles` and `paintBubbles` (beside `createLabels`), and the helper's `net.on('say')`. Gem Rush, Ember Vale and Gem Rush 3D draw what a player says over their name. Each player chooses "Show my messages over my character" and "Show chat on this screen".
+- Rules per game and per server: game.json `"chat"` sets a game's defaults (off, emoji, quick lines or typing; who may type and who may react: anyone, signed in with a passkey, or members; slow mode, length, links, swears, the review, bubbles, watchers, homie.rocks), and the owner overrides them in the office or with `homie-studio chat rules`. A kids server and every beginner server keep chat to emoji and quick lines. By default emoji and quick lines are open to everyone and typing needs a signed-in player account.
+- Moderation in the studio's own Worker before a typed line reaches anyone: a built-in word list and patterns (slurs, sexual words, self-harm, personal questions such as a player's age or where they live, contact details and other apps, links, swears) plus your own words, then a review on your own Workers AI with Cloudflare's Clef decision model (`@cf/cloudflare/clef-flash`), within a daily budget of 2,000 neurons (about 850 typed messages; inside the free allocation). Emoji and quick lines are never reviewed. When the review cannot answer, the word list decides alone. `chat/CHAT.md` says why Clef and what the alternatives cost.
+- The owner's tools: every live room's last minutes in the office with Remove (from every screen), Mute and Kick from a line (a watcher too, their lines taken down with them), the same three in the owner's own game, players' reports with Dismiss, the review's day, and an announcement as a studio line in the chat. `homie-studio chat` (rules, rooms, reports), `chat rules`, `chat remove`, `chat budget` and `chat words`.
+- A studio's `/api/rooms` says which rooms let homie.rocks show their chat (`chat: true`), so homie.rocks's room cards can show a room's chat and emoji live from the room's own socket (the hub's side ships with homie.rocks). Turn it off per game or server with the `hub` rule.
+- `chat/OWNERS.md`: a plain note for studio owners on what the chat tooling does, what is stored and for how long, and children's data (not legal advice).
+- Netplay revision 8 (NETPLAY.md section 19): `say` and `react` frames up, `line`, `react`, `lines`, `unline` and `held` down, `policy.chat`, and the owner's `unsay`; the helper's `net.say`, `net.sayLine`, `net.react`, `net.chatRules` and `on('chat' | 'say' | 'unchat' | 'held')`.
+
+### Changed
+
+- `homie-studio deploy` binds Workers AI when a game lets its players type (the review), not only when an AI guide thinks with it.
+- `homie-studio dev --remote-ai` works again: Wrangler's `--local` turned every remote binding off.
+
+### Upgrade notes
+
+- `homie-studio upgrade --apply` (or the next deploy) adds migration `0007_studio_chat.sql`: the owner's chat rules and players' reports. The chat itself is never stored.
+- Games get the chat panel, the float and the ticker as soon as the studio deploys this version. Rebuild a game to draw speech bubbles (its netplay helper is revision 8).
+- Typing needs a signed-in player account by default. To let guests type, or to keep a game to emoji and quick lines, set game.json `"chat"` or use `homie-studio chat rules`.
+
 ## [0.22.0] - 2026-10-02
 
-**Plugin 0.23.0** · [#32](https://github.com/homie-rocks/homie/pull/32)
+**Plugin 0.23.0** · [#32](https://github.com/homie-rocks/homie/pull/32) · [release-2026-10-03-studio-0.22.0](https://github.com/homie-rocks/homie/releases/tag/release-2026-10-03-studio-0.22.0)
 
 Your game's look as decisions you can steer and lock, a style board the engine draws for free, free CC0 3D models, props made on your own fal account, and every asset licensed and checked for phones.
 

package/README.md

@@ -26,6 +26,7 @@ npx homie-studio publish                               # the homie.rocks directo
 npx homie-studio stats                                 # the studio's own numbers, for its owner
 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 upgrade                               # what a newer template adds to this studio (--apply to take it)
 ```
 
@@ -286,6 +287,42 @@ npx homie-studio agents pass night-rush --label Claude
 - Everything is in the studio's own Worker and D1 (migration `0006_studio_servers.sql`). The site's side is in
   [site/SITE.md](site/SITE.md); the room's in [netplay/NETPLAY.md](netplay/NETPLAY.md) sections 17 and 18.
 
+## Room chat
+
+Every game has room chat (0.23.0), with no game code: reactions that float up every screen in the room (players,
+watchers, the big screen), the game's quick lines, and typing where the room's rules allow it. It is the Homie app's
+live-room chat and homie.rocks's room chat in a studio's own game: the same five reactions in the same order, the
+same message shapes, the same float on a television.
+
+```sh
+npx homie-studio chat rules night-rush --mode lines                    # emoji and quick lines only
+npx homie-studio chat rules night-rush --who anyone --slow 5           # guests may type, one line every 5 s
+npx homie-studio chat rules night-rush --server first-light --mode emoji
+npx homie-studio chat                                                   # rules, every room's last minutes, reports
+npx homie-studio chat remove night-rush pub-3 <line id>                 # take a line down on every screen
+npx homie-studio chat words                                             # the built-in word list the floor holds
+```
+
+- **The play page:** a Chat pill beside the room button (the corner `screen.share` keeps clear of the HUD), its
+  sheet (the last minutes, the reactions, the quick lines, typing, Report), a short ticker of new lines, and two
+  switches each player keeps: "Show my messages over my character" and "Show chat on this screen". The big screen
+  shows the lines in a corner; the watch page has a Chat button; homie.rocks shows a room's chat on its card.
+- **Rules** per game (game.json `"chat"`) and per server, in the office or with `chat rules`: off, emoji, quick
+  lines or typing; who may type and who may react (anyone, signed in with a passkey, members); slow mode, length,
+  links, swears, the review, bubbles, watchers, homie.rocks. Default: emoji and quick lines for anyone, typing for
+  signed-in players. A kids server and every beginner server keep chat to emoji and quick lines.
+- **Moderation, in the studio's own Worker, before anyone sees a typed line:** a built-in word list and patterns
+  (slurs, sexual words, self-harm, personal questions and contact details, links, swears, your own words), then
+  Cloudflare's **Clef** decision model on the studio's own Workers AI (`@cf/cloudflare/clef-flash`, about 2.3
+  neurons a message measured, 2,000 a day by default: inside the free allocation). Emoji and quick lines are never reviewed.
+- **The owner:** every live room's last minutes in the office with Remove, Mute and Kick (from a line, with their
+  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.
+  [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.
+
 ## Setup status
 
 ```sh

package/bin/homie-studio.mjs

@@ -100,6 +100,10 @@
  *                                          tap in their own browser, from the link this prints)
  *   homie-studio office revoke            (every office key, play ticket and pending ask ends)
  *
+ *   homie-studio chat [--game <id>]       room chat (NETPLAY.md section 19): each game's rules, every live room's last
+ *                                          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 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>]
@@ -219,6 +223,7 @@ import { STUDIO_VERSION } from '../lib/version.mjs';
 import { statsKey, statsLink, statsRevoke, statsShare, statsShow } from '../lib/stats.mjs';
 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 { agentsBrain, agentsBrainKey, agentsPass, agentsPasses, agentsRevoke, serversClose, serversLevel, serversLines, serversList, serversMember, serversNew, serversSet } from '../lib/servers.mjs';
 import { AgentSeat } from '../lib/agent-seat.mjs';
 import { Feed, currentFeed, currentId, flushProgress, publicFeed, readFeed, recordChange, startProgress } from '../lib/progress.mjs';
@@ -426,6 +431,20 @@ function print(result) {
     case 'servers':
       lines.push(...serversLines(result));
       break;
+    case 'chat':
+      lines.push(...chatLines(result));
+      break;
+    case 'chat words':
+      for (const [k, v] of Object.entries(result.groups)) lines.push(`${k}: ${v.join(', ')}`);
+      lines.push(result.note);
+      break;
+    case 'chat remove':
+      lines.push(result.message);
+      break;
+    case 'chat rules':
+    case 'chat budget':
+      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;
     case 'servers new':
       lines.push(result.message, ...(result.notes ?? []).map((n) => `  ${n}`));
       break;
@@ -590,6 +609,8 @@ async function main() {
   if (cmd === 'version' || flags.has('version')) return { ok: true, command: 'version', version: STUDIO_VERSION };
   if (cmd === 'new') return newStudio(positional[1], { name: flags.get('name'), homie: flags.get('homie'), slug: flags.get('slug'), install: !flags.has('no-install'), template: flags.has('template') });
   if (cmd === 'starters') return { ok: true, command: 'starters', starters: starters() };
+  // The floor's built-in words need no studio: anyone can read what a studio's chat always holds.
+  if (cmd === 'chat' && sub === 'words') return chatWords();
   if (cmd === 'demo') return demoGames();
   if (cmd === 'mcp') {
     // stdout carries MCP messages only from here on (lib/mcp.mjs); every word for a person goes to stderr.
@@ -706,6 +727,16 @@ 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 === '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');
+    if (sub === 'words') return chatWords();
+    if (!sub) return chatShow(root, { url, game: flags.get('game') });
+    if (sub === 'rules') return chatRulesSet(root, positional[2], flags, { url });
+    if (sub === 'remove') return chatRemove(root, positional[2], positional[3], positional[4], { url, all: flags.has('all') });
+    if (sub === 'budget') return chatBudget(root, positional[2], { url });
+    return { ok: false, command: 'chat', why: `unknown: chat ${sub} (rules, remove, budget, words)` };
+  }
   if (cmd === 'servers') {
     const url = flags.get('url');
     if (!sub || sub === 'list') return serversList(root, { url, game: flags.get('game') });
@@ -928,7 +959,9 @@ async function dev(root) {
   log(`Local site: http://127.0.0.1:${port}/  (each game: http://127.0.0.1:${port}/<id>/play — open it in two browsers)`);
   const ai = devConfig(root, flags.has('remote-ai'));
   if (ai.note) log(ai.note);
-  const child = spawn(bin, ['dev', '--local', '--ip', '127.0.0.1', '--port', port, ...ai.args], { cwd: workerDir(root), env, stdio: 'inherit' });
+  // --remote-ai: Wrangler's --local turns every remote binding off ("not supported"), so a dev with the real Workers AI
+  // (the guides' brains, room chat's review) runs without it; everything else stays local all the same.
+  const child = spawn(bin, ['dev', ...(flags.has('remote-ai') ? [] : ['--local']), '--ip', '127.0.0.1', '--port', port, ...ai.args], { cwd: workerDir(root), env, stdio: 'inherit' });
   mkdirSync(dirname(devFile(root)), { recursive: true });
   writeFileSync(devFile(root), `${JSON.stringify({ pid: process.pid, child: child.pid, port: Number(port), at: new Date().toISOString() })}\n`);
   log(`Stop it with: npx --no-install homie-studio dev --stop   (this studio's dev server only)`);

package/chat/CHAT.md

@@ -0,0 +1,101 @@
+# Room chat
+
+Every studio game has room chat from `@homie-rocks/studio` 0.23.0: reactions that float up every
+screen in the room (the players', the watchers', the big screen's), the game's quick lines, and
+typed messages where the room's rules allow them. It feels like the Homie app's live rooms and
+homie.rocks's room chat because it is the same thing: the same five reactions in the same order,
+the same message shapes, the same float on a television.
+
+The wire, the rules and the helper are in [NETPLAY.md section 19](../netplay/NETPLAY.md). This
+page is the short version for a game's author, and why the review uses what it uses. For what a
+studio's owner is responsible for, read [OWNERS.md](OWNERS.md).
+
+## What a game gets with no work
+
+- **The Chat pill** on the play page, beside the room button: the room's last minutes, the
+  reactions, the quick lines, typing where allowed, Report on a line, and two switches ("Show my
+  messages over my character", "Show chat on this screen").
+- **The float:** every reaction rises up every screen in the room.
+- **The ticker:** a new line shows for a moment where the play page's status chip sits.
+- **The big screen** (`/<game>/tv`) shows the room's lines in a corner; the **watch page** has a
+  Chat button; **homie.rocks** shows the room's chat on its card when the studio allows it.
+
+## What a game can add
+
+**Its rules, in game.json** (the owner can change every one in the office):
+
+```json
+"chat": {
+  "mode": "text",
+  "who": "signed-in",
+  "react": "anyone",
+  "slow": 2,
+  "max": 140,
+  "emoji": { "gem": "💎" },
+  "lines": { "gg": "Good game!", "gem": "Grab that gem!", "help": "Help me!", "wait": "Wait for me!" }
+}
+```
+
+| Field | | Default |
+|---|---|---|
+| `mode` | `off`, `emoji` (reactions only), `lines` (and quick lines), `text` (and typing) | `text` |
+| `who` | who may type: `anyone`, `signed-in` (a player account with a passkey), `members` (of the room's server) | `signed-in` |
+| `react` | who may send reactions and quick lines (the same three) | `anyone` |
+| `slow`, `max` | seconds between one person's lines; a typed line's length | 2, 140 |
+| `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` |
+| `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. Where new lines show for a moment: game.json
+`"screen": { "chat": "bottom-right" }` (any corner, `top-center` or `bottom-center`), or `false`
+for only the pill's count.
+
+**Speech bubbles over characters**, with the port kit (the starters draw them):
+
+```ts
+import { createBubbles, paintBubbles, BUBBLE_FONT } from '@homie-rocks/studio/port';
+const bubbles = createBubbles({ measure: (t) => { ctx.font = BUBBLE_FONT; return ctx.measureText(t).width; } });
+net.on('say', (s) => bubbles.say(s.seat, s.text, { id: s.id, kind: s.kind }));
+net.on('unchat', (e) => e.ids.forEach((id) => bubbles.remove(id)));
+// each frame, after the names: the anchor is just over each speaking body's name
+paintBubbles(ctx, bubbles.place(speakers.map((s) => ({ key: s.seat, x: s.x, y: s.nameTop, self: s.mine }))));
+```
+
+A 3D game draws them the same way on its HUD canvas (Gem Rush 3D does), or reads `place()`'s boxes
+and draws its own. **The game's own chat UI** (a key that opens a wheel of quick lines, say):
+`net.sayLine('gg')`, `net.react('fire')`, `net.say(text)`; `net.on('chat')` for a log of your own.
+
+## Moderation: what it uses, and why
+
+The owner asked for "Cloudflare's new decisions API". That is **Clef**, Cloudflare's decision
+models, launched on Workers AI on 2026-10-01 (Birthday Week): `@cf/cloudflare/clef-flash` (9B) and
+`@cf/cloudflare/clef` (27B). They do not write text: you send a `state` (here, the message) and
+typed questions, and they return a probability for every allowed answer. Cloudflare names "trust
+and safety: score user submissions against your own policy rubric" as a use.
+
+| | Clef-flash (the default) | Clef | Llama Guard 3 8B | AI Gateway Guardrails |
+|---|---|---|---|---|
+| What | a decision model: our own question, a probability per answer | the same, larger | Meta's fixed safety categories (S1–S14) | Llama Guard run on prompts and responses of model calls through a gateway |
+| Price | $0.09 per M input tokens, no output charge: measured about 2.3 neurons a short message (the question is most of it) | $0.24 per M: about 6 neurons | $0.48 per M in, $0.03 out: up to about 10 neurons a message with its policy prompt | Llama Guard's price, plus the model call it guards |
+| Speed | about 40 ms median, 120 ms p95 (Cloudflare's numbers) | about 210 ms median | about 500 ms (Cloudflare's guardrails notes) | a model call plus about 500 ms |
+| Fits game chat | our categories: insults, hate, sexual, grooming, harm, spam | the same, more accurate | no insults or bullying category; most game-chat abuse reads as "safe" | not for arbitrary text: it guards model traffic |
+
+Clef-flash is the default because it is the cheapest per message by about five times, the fastest
+by far (a message waits for it before anyone sees it), and lets the studio ask exactly what game
+chat needs. Honest caveats: it is one day old as this ships, Cloudflare publishes no moderation
+accuracy numbers for it, and the message it reads is a player's, so a player can try to steer it
+(less of a risk than with a model that writes, since it only scores fixed answers). That is why
+**the word list always runs first and decides alone** whenever the review cannot (no binding, the
+day's budget used, an error, a slow answer). `HOMIE_CHAT_MODEL` switches to Clef or Llama Guard.
+Firewall for AI (now "AI Security for Apps") was ruled out: it reads HTTP requests at the zone, not
+messages inside a Durable Object, and its detections are an Enterprise add-on.
+
+**What it costs a studio.** Workers AI gives every account 10,000 neurons a day free, on the free
+Workers plan too, with no payment method. The review's day is 2,000 neurons by default (about
+850 typed messages, measured), leaving the AI guides their 8,000; `homie-studio chat budget <n>` changes it. On the free plan, past the allocation
+Workers AI refuses (the floor decides); on Workers Paid, past it is $0.011 per 1,000 neurons, which
+is why the review stops at its own budget. `homie-studio deploy` binds Workers AI when a game lets
+players type; `homie-studio dev --remote-ai` uses the real one (billed to the signed-in account).

package/chat/OWNERS.md

@@ -0,0 +1,78 @@
+# Room chat: a note for studio owners
+
+**This is not legal advice.** It says what Homie's tooling does and does not do, so you can decide
+what your studio needs. Laws about online chat and children's data differ by country and change;
+if your games are for children, or many children play them, talk to someone who advises on that
+where you and your players are.
+
+## Your studio, your rooms, your responsibility
+
+A Homie studio runs on **your own Cloudflare account**: your Worker, your Durable Objects, your D1
+database, your Workers AI. Homie (and homie.rocks) does not run your rooms, does not see your
+players' chat, and does not moderate it for you. You choose the rules, you hold the owner's
+controls, and you are the one responsible for what happens in your rooms, as the operator of the
+service. Homie gives you the tools to do that well; it cannot do it for you.
+
+What that means in practice:
+
+- **Choose rules that fit your players.** Each game sets its defaults in game.json, and you change
+  them per game and per server in the office (`/_studio/office`) or with `homie-studio chat rules`.
+  If your players are young, keep chat to emoji and quick lines, or put them on a kids server (a
+  beginner server with `kids` on): typing is then off whatever the game says.
+- **Watch your rooms, and act.** The office shows every live room's last minutes. Remove a message,
+  mute or kick its sender (their messages come down with them), and read what players report.
+- **Answer reports.** Players can report a message. You see it in the office and with
+  `homie-studio chat`; dismiss it once you have dealt with it.
+- **Say who your game is for, and what chat it has,** on your game's page and in your own terms or
+  rules, if you have them.
+
+## What the tooling does
+
+| | |
+|---|---|
+| **Who can say what** | By default: everyone can send emoji and the game's quick lines; only **signed-in players** (an account with a passkey on your studio) can type. You can open typing to guests, keep it to members of a server, keep a room to emoji or quick lines, or turn chat off. |
+| **Before anyone sees a typed message** | 1) a built-in word list and patterns (slurs, sexual words, telling someone to hurt themselves, asking a player's age or where they live, asking for pictures, moving a player to another app, email addresses and phone numbers, links, swears), plus your own words; 2) a review on your own Workers AI (Cloudflare's Clef decision model) that holds insults, hate, sexual content, grooming, threats and spam. The list always runs; the review runs within a daily budget. Neither is perfect: both are English-first, and a determined person can get past any filter. |
+| **Emoji and quick lines** | Fixed words you (the game) chose. They are never reviewed and reach every screen at once. |
+| **Children** | A kids server keeps chat to emoji and quick lines, gives players handles instead of names, and never asks anyone's age. Homie never asks for a player's age, birthday or address anywhere. |
+| **AI players** | An AI never types in room chat. |
+| **Slow mode and limits** | One line every 2 s by default (you choose), and message length, repeats and floods are capped. |
+
+## What is stored, and for how long
+
+| 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. |
+| 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. |
+| Counts (messages sent, held and why, reviews) | Your D1 (`stats_daily`) | Daily numbers, never a message and never a person. |
+| Player accounts | Your D1 (the players tables, `saves/SAVES.md`) | A random id, a display name, a passkey's public key. No email unless a player adds one; players can download and delete everything of theirs at `/account/`. |
+
+**The review** sends a typed message's words (and nothing about who wrote it) to Workers AI on your
+own Cloudflare account. Cloudflare says it does not store or train on Clef's requests or responses.
+**homie.rocks** stores nothing of your chat: when your rules allow it, a visitor's own browser opens
+your room's socket to show its chat on your room's card there. Turn that off with `hub` off.
+
+## Children's data, in plain words
+
+Laws in many places (for example COPPA in the United States, GDPR and the UK's Children's Code in
+Europe and the UK) set rules for online services that collect personal information from children,
+or that are directed at children. A typed message can contain personal information. What helps:
+
+- **Keep chat to emoji and quick lines for games aimed at children** (or a kids server). Then no
+  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.
+- **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).
+
+Homie does not know your players' ages and does not verify them. Whether your game is "directed at
+children", and what that requires of you, is for you to decide with advice where you need it.
+
+## What the tooling cannot promise
+
+No filter catches everything, and a review model can be wrong both ways. The word list is English;
+other languages rely on the review. A studio past its daily review budget, or whose Worker has no
+Workers AI binding yet, relies on the word list alone until the next day (the office says so). Your
+attention, your rules and your owner's controls are the real safety net.

package/lib/build.mjs

@@ -45,6 +45,7 @@ import { SEAT_MAX } from '../worker/seats.mjs';
 import { STUDIO_VERSION } from './version.mjs';
 import { licenseOf, remixRow } from '../worker/license.mjs';
 import { SERVER_LIMITS, serverOf } from '../worker/servers.mjs';
+import { chatProblems } from '../worker/chat.mjs';
 import { vocabularyOf } from '../worker/brain.mjs';
 
 const SOURCE_SKIP = new Set(['node_modules', 'dist', '.git', '.wrangler', '.port']);
@@ -312,6 +313,9 @@ export async function build(root, { only = null, log = () => {}, deploy = proces
     const { mode, warnings } = await buildGameFiles(esbuild, root, g, out, { maps, cache, log });
     // The guides' vocabulary (NETPLAY.md section 18): checked here, so a room never meets a line it cannot say.
     vocabFor(g, out);
+    // Room chat (NETPLAY.md section 19): game.json "chat", checked here (its quick lines pass the chat floor too).
+    const chatBad = chatProblems(g.chat);
+    if (chatBad.length) throw new Error(`games/${g.id}/game.json: ${chatBad.join('; ')}`);
     // The game's own source, for other studios to remix (game.json "share": { "source": false } keeps it private).
     if (g.share?.source !== false) writeFileSync(join(out, 'source.json'), `${JSON.stringify(sourceOf(g.dir, g.id, { studio: studio.name ?? null, game: g.name ?? g.id, license: g.license }))}\n`);
     // Its assets' licences, and the address and SHA-256 of each one a remix may carry (`game remix` fetches them).
@@ -356,6 +360,9 @@ export async function build(root, { only = null, log = () => {}, deploy = proces
       // game.json `"watch"` (NETPLAY.md section 16): watchers see any player's view (the default), only the whole room
       // ("overview": hidden hands or roles), or nothing (false: no watch door).
       ...(g.watch === 'overview' ? { watch: 'overview' } : g.watch === false || g.watch === 'off' ? { watch: 'off' } : {}),
+      // game.json `"chat"` (0.23.0, NETPLAY.md section 19): the room chat's defaults for this game (the owner's office
+      // overrides them), or false for none.
+      ...(g.chat === false ? { chat: false } : g.chat && typeof g.chat === 'object' ? { chat: g.chat } : {}),
       // Servers (0.16.0): the seeds game.json ships, the netplay revision its build speaks (the office warns when it
       // predates servers), and game.json "agents": { "vote": "game" | false } (the game draws its own vote card, or none).
       ...(seeds.length ? { servers: seeds } : {}),

package/lib/chat-cli.mjs

@@ -0,0 +1,89 @@
+/**
+ * `homie-studio chat` — a studio's room chat from the studio folder (worker/chat.mjs says what it is; NETPLAY.md
+ * section 19 the rules and the wire). The office key it uses is the same as `office`'s: minted with the studio's own
+ * Cloudflare login, ten minutes long, dropped as soon as the answer is in.
+ *
+ *   homie-studio chat [--game <id>]                    each game's chat rules, every live room's last minutes, the
+ *                                                      reports, and the review's day (neurons used of its budget)
+ *   homie-studio chat rules <game> [--server <id>] [--mode off|emoji|lines|text] [--who anyone|signed-in|members]
+ *                          [--react …] [--slow <s>] [--max <n>] [--links block|allow] [--swears block|allow]
+ *                          [--ai on|off] [--bubbles on|off] [--watchers on|off] [--hub on|off] [--block "a,b"] [--reset]
+ *   homie-studio chat remove <game> <room> <line id>|--all
+ *   homie-studio chat budget <neurons>                  the review's day for the whole studio (default 2,000)
+ *   homie-studio chat words                             the built-in word list the floor holds (worker/chat-words.mjs)
+ *
+ * A change that opens chat up (a wider mode or audience, less slow mode, links or swears allowed, the review off) or
+ * a bigger budget is only ASKED for here: the answer is the owner's one-tap link, as `office kick` gives.
+ */
+import { builtinWords } from '../worker/chat.mjs';
+import { askedFor, withKey } from './office.mjs';
+
+const GAME = /^[a-z0-9][a-z0-9-]{0,39}$/;
+const onOff = (v) => (v === undefined ? undefined : v === true || v === 'on' || v === 'true' || v === 'yes');
+
+/** The flags `chat rules` reads, as the office API's fields. */
+export function chatFields(flags) {
+  const f = {};
+  const get = (k) => (flags.has(k) ? flags.get(k) : undefined);
+  for (const k of ['mode', 'who', 'react', 'links', 'swears']) if (get(k) !== undefined) f[k] = String(get(k));
+  for (const k of ['slow', 'max']) if (get(k) !== undefined) f[k] = Number(get(k));
+  for (const k of ['ai', 'bubbles', 'watchers', 'hub']) if (get(k) !== undefined) f[k] = onOff(get(k));
+  if (get('block') !== undefined) f.block = String(get('block')).split(',').map((w) => w.trim()).filter(Boolean);
+  if (get('allow') !== undefined) f.allow = String(get('allow')).split(',').map((w) => w.trim()).filter(Boolean);
+  return f;
+}
+
+export async function chatShow(root, { url, game } = {}) {
+  const r = await withKey(root, url, (call) => call(`/_studio/api/chat${game ? `?game=${encodeURIComponent(game)}` : ''}`));
+  if (!r.ok) return { ok: false, command: 'chat', why: r.why ?? r.message ?? 'the office did not answer' };
+  return { command: 'chat', ...r, ok: true };
+}
+
+export async function chatRulesSet(root, game, flags, { url } = {}) {
+  if (!GAME.test(String(game ?? ''))) return { ok: false, command: 'chat rules', why: 'usage: homie-studio chat rules <game> [--server <id>] --mode off|emoji|lines|text [--who …] [--slow <s>] … | --reset' };
+  const server = flags.get('server') ?? '';
+  const body = flags.has('reset') ? { game, server, reset: true } : { game, server, ...chatFields(flags) };
+  if (!body.reset && Object.keys(body).length <= 2) return { ok: false, command: 'chat rules', why: 'say what to change: --mode, --who, --react, --slow, --max, --links, --swears, --ai, --bubbles, --watchers, --hub, --block, --allow; or --reset' };
+  const r = await withKey(root, url, (call) => call('/_studio/api/chat/rules', body));
+  return askedFor(root, url, r, 'chat rules');
+}
+
+export async function chatRemove(root, game, room, id, { url, all = false } = {}) {
+  if (!GAME.test(String(game ?? '')) || !room || (!id && !all)) return { ok: false, command: 'chat remove', why: 'usage: homie-studio chat remove <game> <room> <line id> | --all (the ids are in `homie-studio chat`)' };
+  const r = await withKey(root, url, (call) => call('/_studio/api/chat/remove', { game, room, ...(all ? { all: true } : { id }) }));
+  return r.ok ? { ok: true, command: 'chat remove', removed: r.removed ?? 0, message: `Took ${r.removed ?? 0} message${r.removed === 1 ? '' : 's'} down in ${room}, on every screen.` } : { ok: false, command: 'chat remove', why: r.message ?? r.why };
+}
+
+export async function chatBudget(root, neurons, { url } = {}) {
+  const n = Math.floor(Number(neurons));
+  if (!(n >= 0 && n <= 1e7)) return { ok: false, command: 'chat budget', why: 'usage: homie-studio chat budget <neurons a day> (default 2000; Workers AI gives an account 10,000 a day free)' };
+  const r = await withKey(root, url, (call) => call('/_studio/api/chat/budget', { neurons: n }));
+  return askedFor(root, url, r, 'chat budget');
+}
+
+/** The built-in list, by group: what the floor always holds (swears only while a game holds swears). */
+export function chatWords() {
+  const w = builtinWords();
+  return {
+    ok: true, command: 'chat words',
+    groups: {
+      slurs: [...w.slurs], slursInsideWords: w.slursAnywhere, sexual: [...w.sexual], sexualInsideWords: w.sexualAnywhere,
+      swears: [...w.swears], swearsInsideWords: w.swearsAnywhere, harm: w.harm, contact: w.contact,
+    },
+    note: 'Whole words unless "inside words". Shown as the floor reads them (lower case, letters only). A studio adds its own with chat rules --block, and lets one through with --allow.',
+  };
+}
+
+export function chatLines(r) {
+  const out = [];
+  const d = r.day;
+  if (d) out.push(`Review today: ${d.ai ? `${Math.round(d.used.neurons)} of ${d.budget.neurons} neurons, ${d.used.reviews} reviewed, ${d.used.held} held${d.used.errors ? `, ${d.used.errors} unanswered (the word list decided)` : ''}` : 'no Workers AI binding yet (npm run deploy binds it); the word list decides'}.`);
+  for (const g of r.games ?? []) {
+    const c = g.chat?.rules;
+    out.push(`${g.name} (${g.id}): ${c ? `${c.mode}${c.mode === 'text' ? `, typing ${c.who}` : ''}, emoji ${c.react}, slow ${c.slow} s${c.ai ? ', reviewed' : ''}${c.capped ? ` (capped: ${c.capped})` : ''}` : 'no rules read'} · from ${g.chat?.from ?? 'default'}`);
+    for (const sv of g.chat?.servers ?? []) if (sv.office) out.push(`  server ${sv.id}: ${sv.rules.mode}, typing ${sv.rules.who}`);
+    for (const rm of g.rooms ?? []) for (const l of (rm.chat?.lines ?? []).slice(-8)) out.push(`  ${rm.room} ${l.id}  ${l.by === 'studio' ? 'Studio' : l.name}: ${l.kind === 'react' ? l.glyph : l.text}`);
+    for (const p of g.chat?.reports ?? []) out.push(`  report ${p.id}: "${p.text}" by ${p.name} (${p.reasonText}), ${p.room}`);
+  }
+  return out;
+}

package/lib/cloudflare.mjs

@@ -218,7 +218,7 @@ export async function deploy(root, { log = () => {}, homie } = {}) {
   // Workers AI (0.17.0): bound only when a server's AI guides think with it.
   if (needsWorkersAi(root, w, cf.d1)) {
     writeFileSync(configPath(root), wranglerConfig({ worker: cf.worker, name: studio.name, d1: cf.d1, d1Id: db.uuid, r2, layout: layoutOf(root), ai: true }));
-    step('Workers AI bound (AI): a server\'s AI guides think with it, within the day\'s budget (free allocation: 10,000 neurons a day)');
+    step('Workers AI bound (AI): a server\'s AI guides think with it and typed room chat is reviewed with it, each within its day\'s budget (free allocation: 10,000 neurons a day)');
   }
 
   const started = Date.now();
@@ -271,6 +271,9 @@ export function needsWorkersAi(root, w, db) {
   try {
     const cat = JSON.parse(readFileSync(join(root, 'site', 'dist', 'games.json'), 'utf8'));
     if ((cat.games ?? []).some((g) => (g.servers ?? []).some((s) => s.brain === 'workers-ai'))) return true;
+    // Room chat (0.23.0): a game whose players may type has its messages reviewed by the studio's own Workers AI
+    // (Cloudflare's Clef decision model, within a day's budget of the free allocation) unless its game.json says no.
+    if ((cat.games ?? []).some((g) => g.chat !== false && (g.chat?.mode ?? 'text') === 'text' && g.chat?.ai !== false)) return true;
   } catch { /* not built */ }
   const r = w(['d1', 'execute', db, '--remote', '--json', '--command', "SELECT COUNT(*) AS n FROM servers WHERE brain = 'workers-ai' AND state = 'open'"]);
   if (r.code !== 0) return false;
@@ -343,7 +346,7 @@ export async function ciDeploy(root, { log = () => {} } = {}) {
     try {
       const json = JSON.parse(readFileSync(configPath(root), 'utf8').replace(/^\s*\/\/.*$/gm, ''));
       if (!json.ai) { json.ai = { binding: 'AI' }; writeFileSync(configPath(root), `${JSON.stringify(json, null, 2)}\n`); }
-      step('Workers AI bound (AI) for the AI guides');
+      step('Workers AI bound (AI): the AI guides and the review of typed room chat');
     } catch { step('could not add the Workers AI binding to wrangler.jsonc: the guides answer from the game\'s script'); }
   }
   const started = Date.now();

package/lib/scaffold.mjs

@@ -28,6 +28,7 @@ import { STATS_MIGRATION, STATS_MIGRATION_FILE } from '../worker/stats.mjs';
 import { PLAYERS_MIGRATION, PLAYERS_MIGRATION_FILE } from '../worker/players.mjs';
 import { OFFICE_MIGRATION, OFFICE_MIGRATION_FILE } from '../worker/office-schema.mjs';
 import { SERVERS_MIGRATION, SERVERS_MIGRATION_FILE } from '../worker/servers.mjs';
+import { CHAT_MIGRATION, CHAT_MIGRATION_FILE } from '../worker/chat-store.mjs';
 import { themeFile } from './site.mjs';
 
 export const COMPAT_DATE = '2026-06-01';
@@ -571,6 +572,7 @@ export { default, Table, Lobby } from '@homie-rocks/studio/worker';
     [`site/migrations/${PLAYERS_MIGRATION_FILE}`]: PLAYERS_MIGRATION,
     [`site/migrations/${OFFICE_MIGRATION_FILE}`]: OFFICE_MIGRATION,
     [`site/migrations/${SERVERS_MIGRATION_FILE}`]: SERVERS_MIGRATION,
+    [`site/migrations/${CHAT_MIGRATION_FILE}`]: CHAT_MIGRATION,
     'wrangler.jsonc': wranglerConfig({ worker, name, d1: studio.cloudflare.d1, r2: studio.cloudflare.r2, layout: 'root' }),
     '.claude/skills/.gitkeep': '',
   };
@@ -663,13 +665,22 @@ export function ensureServersMigration(root) {
 }
 
 /** Every migration the template owns that this studio lacks, added: the files written (deploy and dev say so). */
+/** A studio made before 0.23.0 has no room chat tables: the owner's chat rules and players' reports. */
+function ensureChatMigration(root) {
+  const file = join(root, 'site', 'migrations', CHAT_MIGRATION_FILE);
+  if (existsSync(file)) return null;
+  mkdirSync(dirname(file), { recursive: true });
+  writeFileSync(file, CHAT_MIGRATION);
+  return `site/migrations/${CHAT_MIGRATION_FILE}`;
+}
+
 export function ensureMigrations(root) {
-  return [ensureStatsMigration(root), ensurePlayersMigration(root), ensureOfficeMigration(root), ensureServersMigration(root)].filter(Boolean);
+  return [ensureStatsMigration(root), ensurePlayersMigration(root), ensureOfficeMigration(root), ensureServersMigration(root), ensureChatMigration(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 /players/.test(file) ? 'player accounts and cloud saves' : /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 /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

@@ -962,6 +962,44 @@
      }
     }
    }
+  },
+  "0.23.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": "ca131cd0472464fb",
+    "site/src/worker.mjs": "ca3f1630f2420ad3"
+   },
+   "sections": {
+    "AGENTS.md": {
+     "(intro)": "214aa46eb3a895d5",
+     "## Layout": "8baf49e4291e7e88",
+     "## Commands (all through the pinned CLI in node_modules)": "d80ec56e4b4fc4c6",
+     "## The site": "ab922bb6bde23293",
+     "## Making games": "a8a893eeada33bf5",
+     "## The Game Codex and progress": "0738ef719cef3a4c",
+     "## Art direction and models": "124772c374de7390",
+     "## Running live games (the back office)": "4aa5f513a7cd2c3b",
+     "## Servers and AI seats": "0a332b07e22d3fce",
+     "## Continuing a build from the Claude app": "0d68081e924ca419",
+     "## Rules": "7e8458adc1b81ece",
+     "## Beta": "9d02638207a26e73"
+    }
+   },
+   "named": {
+    "Homie Arcade": {
+     "sections": {
+      "AGENTS.md": {
+       "## Commands (all through the pinned CLI in node_modules)": "b35df2c19cd4b534"
+      }
+     }
+    }
+   }
   }
  }
 }