@homie-rocks/studio 0.28.0 → 0.30.0

package/CHANGELOG.md

@@ -5,7 +5,7 @@ What changed in each release of Homie's open parts, newest first:
 - **`@homie-rocks/studio`**: the `homie-studio` command, your studio's site Worker, its multiplayer rooms (the
   netplay contract), the port kit and the starter games. Every version is on npm, and Homie for Claude Desktop
   (`homie-studio-<version>.mcpb` on each GitHub release) is built from it.
-- **The Homie plugin** for Claude Code and Codex: its skills. It ships from this repository's marketplace with its
+- **The Homie plugin** for Claude Code, Codex and Grok: its skills. It ships from this repository's marketplace with its
   own version number, given beside each studio version below.
 
 Each version says what you can now do (**Added**), what works differently (**Changed**), what was broken and is
@@ -17,9 +17,54 @@ 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.30.0] - 2026-10-03
+
+**Plugin 0.31.0** · [#45](https://github.com/homie-rocks/homie/pull/45)
+
+Grok can set up a studio and run it with the same holds as Claude Code and Codex.
+
+### Added
+
+- `homie-studio setup attach <hs_…> --client grok` and `homie-studio handoff <hb_…> --client grok`. A Grok Bot in the studio folder checks the repository in. The directory is told the chat is Grok. Claude and Codex pass `--client claude` or `--client codex`; with no `--client` the words stay "the chat".
+- Homie's hooks for Grok Build (`plugins/homie/.grok-plugin/plugin.json`, `hooks/grok.json`, `hooks/grok.mjs`). They ask `hooks/lib/holds.mjs`, the module the Claude Code mod and the Codex hooks already ask, so the three hold the same calls with the same words. A held call waits for your own `proceed <code>`. Secrets are taken out of what Grok reads.
+- A new studio's home band says **Connect this chat**, for Claude, Codex or Grok. Grok has no Cloudflare connector: approving Cloudflare in the browser is still your step.
+
+### Changed
+
+- The plugin manifests (Claude Code, Codex, Grok and `plugin.json`) name plugin 0.31.0 and say the same thing. `plugins/homie/test/manifests.test.mjs` checks the Grok manifest with the others.
+
+## [0.29.0] - 2026-10-03
+
+**Plugin 0.30.0** · [#44](https://github.com/homie-rocks/homie/pull/44) · [release-2026-10-03-studio-0.29.0](https://github.com/homie-rocks/homie/releases/tag/release-2026-10-03-studio-0.29.0)
+
+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)
+**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.
 

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)
 ```
 
@@ -82,8 +83,8 @@ The button copies the public template (`template/` in this repository, exactly w
 writes) into the person's GitHub, makes the Worker, the D1 database and the rooms on their Cloudflare account,
 and connects Workers Builds. The site goes live with its own home page ("First game coming soon": no starter game
 is put in a studio unless the person asks for one), and its Home has a
-**Connect to Claude** band: one tap links it to the Claude chat that set it up (the Homie MCP tool `studio_setup`).
-In the Claude Code session that works in the repository, `homie-studio setup attach <hs_…>` then gives the studio
+**Connect this chat** band: one tap links it to the chat that set it up (the Homie MCP tool `studio_setup`).
+In the session that works in the repository, `homie-studio setup attach <hs_…> [--client claude|codex|grok]` then gives the studio
 the name chosen in the chat and removes the band.
 
 **The site claims itself in the directory.** The homie.rocks directory lists a studio only when its site serves
@@ -353,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

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>]
@@ -168,10 +173,12 @@
  *                                         into it (stage, each check going green, a preview picture) and stop
  *                                         when asked. Without one, nothing changes.
  *
- *   homie-studio handoff <hb_…>           (a Claude Code session started from the Claude app with one line, "Continue building
+ *   homie-studio handoff <hb_…> [--client claude|codex|grok]
+ *                                          (a session started from the chat with one line, "Continue building
  *                                          <Studio>: build hb_…": fetch the person's brief, check in for a new studio, take
  *                                          the build so the chat's card follows it, and print the steps; HANDOFF.md)
- *   homie-studio setup attach <hs_…>      (this repository is the studio the Claude app's setup card is making: say so, once,
+ *   homie-studio setup attach <hs_…> [--client claude|codex|grok]
+ *                                          (this repository is the studio the chat's setup card is making: say so, once,
  *                                          learn its live address, and give a template copy its real name)
  *   homie-studio setup --via stripe-projects [--with elevenlabs] [--accept-tos] [--dry-run]
  *                                         (a prototype, 0.24.3: Cloudflare, and ElevenLabs with --with, made or linked
@@ -258,6 +265,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 +487,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 +511,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;
@@ -698,14 +713,14 @@ async function main() {
   if (cmd === 'statusline') return installStatusLine(root, { remove: flags.has('remove'), replace: flags.has('replace'), project: flags.get('project') ?? null });
   if (cmd === 'codex') return codexCommand(root, sub);
   if (cmd === 'progress') return progressCommand(root, sub);
-  if (cmd === 'setup' && sub === 'attach') return setupAttach(root, positional[2], { homie: flags.get('homie') });
+  if (cmd === 'setup' && sub === 'attach') return setupAttach(root, positional[2], { homie: flags.get('homie'), client: flags.get('client') });
   if (cmd === 'setup' && flags.has('via')) {
     if (flags.get('via') !== 'stripe-projects') return { ok: false, command: 'setup', why: '--via stripe-projects is the one other way this version knows (the default is npx wrangler login)' };
     const extra = String(flags.get('with') ?? '').split(',').map((x) => x.trim()).filter(Boolean);
     if (extra.some((x) => x !== 'elevenlabs')) return { ok: false, command: 'setup', why: '--with takes elevenlabs (Cloudflare is always set up)' };
     return setupViaProjects(root, { withElevenlabs: extra.includes('elevenlabs'), acceptTos: flags.has('accept-tos'), dryRun: flags.has('dry-run'), log });
   }
-  if (cmd === 'handoff') return handoff(root, sub, { homie: flags.get('homie') });
+  if (cmd === 'handoff') return handoff(root, sub, { homie: flags.get('homie'), client: flags.get('client') });
   if (cmd === 'port' && sub === 'import') return importPort(root, positional[2], flags.get('id'), { name: flags.get('name'), mode: flags.get('mode') });
   if (cmd === 'port' && sub === 'check') {
     const game = positional[2] ?? listGames(root)[0]?.id;
@@ -791,6 +806,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/client.mjs

@@ -0,0 +1,19 @@
+/**
+ * Which chat is building the studio. Named only when the session says so (`--client`, or HOMIE_CLIENT).
+ * Anything else is "the chat": never a guess that it is Claude. Grok has no Cloudflare connector and no
+ * Claude Code window; `--client grok` is how a Grok Bot checks a repository in.
+ */
+const KNOWN = {
+  claude: { id: 'claude', card: "the Claude app's card", connect: 'Connect this chat' },
+  codex: { id: 'codex', card: "Codex's card", connect: 'Connect this chat' },
+  grok: { id: 'grok', card: "Grok's card", connect: 'Connect this chat' },
+  chat: { id: 'chat', card: 'the setup card', connect: 'Connect this chat' },
+};
+const ALIAS = { 'claude-code': 'claude', 'claude-app': 'claude', 'grok-bot': 'grok', grokbot: 'grok' };
+
+/** @param {string | null | undefined} input  `--client`, or null to read HOMIE_CLIENT */
+export function studioClient(input, env = process.env) {
+  const raw = String(input ?? env.HOMIE_CLIENT ?? '').trim().toLowerCase();
+  const id = ALIAS[raw] ?? raw;
+  return KNOWN[id] ?? KNOWN.chat;
+}

package/lib/doctor.mjs

@@ -152,7 +152,7 @@ export async function setupStatus({
   {
     const fixConnector = {
       who: 'person',
-      say: 'Turn the Homie connector on. Claude Code: run /plugin, install or enable "homie" (marketplace homie-rocks/homie), then /mcp shows homie connected. Codex: install the Homie plugin from the same marketplace. The Claude app: Settings, Connectors, Add custom connector, https://homie.rocks/mcp; then its setup card (studio_setup) makes the studio on your own Cloudflare and GitHub in three taps.',
+      say: 'Turn the Homie connector on. Claude Code: run /plugin, install or enable "homie" (marketplace homie-rocks/homie), then /mcp shows homie connected. Codex: install the Homie plugin from the same marketplace. Grok Build: the same plugin (.grok-plugin/plugin.json). The Claude app, or Grok: add the connector https://homie.rocks/mcp; its setup card (studio_setup) makes the studio on your own Cloudflare. Grok has no Cloudflare connector: you still approve Cloudflare in the browser. A Grok Bot on this computer runs the checklist and checks in with setup attach <hs_…> --client grok.',
     };
     let state; let detail;
     if (net.blocked) { state = 'act'; detail = `the network proxy of this machine refused ${new URL(directory).host}`; }
@@ -162,7 +162,7 @@ export async function setupStatus({
     else { state = 'unknown'; detail = net.ok ? `${new URL(directory).host} answers; your AI knows whether its Homie tools (studio_scaffold) are here` : `this computer's request to the directory failed: ${net.why}`; }
     rows.push({
       id: 'connector', label: 'Homie connector', need: 'required', state, detail,
-      unlocks: 'making the studio with the right toolkit version, listing games in the homie.rocks directory, and the cards in the Claude app',
+      unlocks: 'making the studio with the right toolkit version, listing games in the homie.rocks directory, and the setup cards',
       fix: state === 'ok' ? null : net.blocked
         ? { who: 'person', say: `In claude.ai/code, open this environment's settings, set Network access to Custom, add ${new URL(directory).host} (keep the default package managers), and start a new session.` }
         : said === 'no' || net.ok ? fixConnector : null,
@@ -174,13 +174,13 @@ export async function setupStatus({
     const local = root ? readLocal(root) : {};
     const created = studio?.cloudflare?.created ?? [];
     const deployed = Boolean(local.deployedAt || created.some((c) => String(c).startsWith('worker:')));
-    // A studio the Claude app's setup card made (`setup attach` wrote connectedAt): Cloudflare's Deploy button made
+    // A studio the setup card made (`setup attach` wrote connectedAt): Cloudflare's Deploy button made
     // it on the person's account and Workers Builds deploys every merge, so no sign-in is needed on this computer.
     const attached = Boolean(local.connectedAt);
     const signedIn = attached || who.signedIn === true ? 'ok' : who.signedIn === false ? 'act' : 'later';
     const verified = deployed || attached ? 'ok' : local.needs === 'cloudflare-verify-email' ? 'act' : 'later';
     const parts = attached ? [
-      { label: 'connected', state: 'ok', detail: 'through the Claude app\'s setup card (Deploy to Cloudflare); Workers Builds deploys every merge' },
+      { label: 'connected', state: 'ok', detail: 'through the setup card (Deploy to Cloudflare); Workers Builds deploys every merge' },
       { label: 'email verified', state: 'ok', detail: 'the site is live' },
     ] : [
       { label: 'signed in', state: signedIn, detail: who.signedIn === true ? (who.how ?? `${who.accounts ?? 1} account${who.accounts === 1 || who.accounts === null || who.accounts === undefined ? '' : 's'}`) : who.signedIn === false ? 'not signed in' : root ? (who.why ?? 'run npm install in the studio, then this again') : 'checked once the studio exists (it brings its own Wrangler)' },

package/lib/handoff.mjs

@@ -15,6 +15,7 @@ import { request } from './net.mjs';
 import { startProgress } from './progress.mjs';
 import { spawnSync } from 'node:child_process';
 import { studioRepo } from './repo.mjs';
+import { studioClient } from './client.mjs';
 
 /** The repository this checkout IS (its origin remote), even Homie's engine one: the session must be in the studio's. */
 function originRepo(root) {
@@ -36,13 +37,13 @@ const line = (v, max) => String(v ?? '').replace(/[\x00-\x1f\x7f]+/g, ' ').repla
 const lines = (v, max) => String(v ?? '').split(/\r?\n/).map((l) => line(l, max)).filter(Boolean).join('\n').slice(0, max);
 
 /** The steps for a kind of build, in this toolkit's commands (the brief says what; these say how). */
-export function stepsFor(h, { games = [] } = {}) {
+export function stepsFor(h, { games = [], client = 'chat' } = {}) {
   const id = ID.test(String(h.id ?? '')) ? h.id : null;
   const has = id && games.includes(id);
   const q = (s) => JSON.stringify(String(s));
   const work = {
     setup: [
-      'This studio was just set up from the Claude app. Go through the new-studio checklist with the person, one step at a time and never ahead (the plugin\'s studio-setup skill): it has no game yet, and its home page says "First game coming soon".',
+      `This studio was just set up from ${client === 'grok' ? 'Grok' : client === 'codex' ? 'Codex' : client === 'claude' ? 'the Claude app' : 'this chat'}. Go through the new-studio checklist with the person, one step at a time and never ahead (the plugin's studio-setup skill): it has no game yet, and its home page says "First game coming soon".`,
       'See a working game: `npx --no-install homie-studio demo` names a live one on Homie Arcade; copy a starter in only if they ask.',
       'One small change from one sentence of theirs (the studio\'s colours in site/theme.json, a tagline in studio.json, or a first post in posts/), then plan their game into its Game Codex (`npx --no-install homie-studio codex new <id> --name "<Name>"`) before any game is made.',
     ],
@@ -67,16 +68,17 @@ export function stepsFor(h, { games = [] } = {}) {
   ];
 }
 
-export async function handoff(root, build, { homie, fetchFn = globalThis.fetch, attach = startProgress, checkIn = setupAttach, repoOf = originRepo } = {}) {
+export async function handoff(root, build, { homie, client, fetchFn = globalThis.fetch, attach = startProgress, checkIn = setupAttach, repoOf = originRepo } = {}) {
   const studio = readStudio(root);
+  const who = studioClient(client);
   // "Continue building <Studio>: setup hs_…": a studio being set up, before any build: check in, then the checklist.
   if (SETUP.test(String(build ?? ''))) {
-    const r = await checkIn(root, build, { homie });
+    const r = await checkIn(root, build, { homie, client: who.id === 'chat' ? null : who.id });
     if (!r.ok) return { ok: false, command: 'handoff', setup: build, why: r.why, ...(r.needs ? { needs: r.needs } : {}) };
     const h = { kind: 'setup', what: 'game', title: 'first steps', studio: r.name ?? studio.name, brief: '', setup: build };
-    return { ok: true, command: 'handoff', build: null, ...h, setup: { ok: true, message: r.message, renamed: r.renamed ?? [] }, attached: null, attachWhy: 'no build was opened in the chat yet (the setup card\'s Start building opens one)', steps: stepsFor(h) };
+    return { ok: true, command: 'handoff', build: null, ...h, client: who.id, setup: { ok: true, message: r.message, renamed: r.renamed ?? [] }, attached: null, attachWhy: 'no build was opened in the chat yet (the setup card\'s Start building opens one)', steps: stepsFor(h, { client: who.id }) };
   }
-  if (!BUILD.test(String(build ?? ''))) return { ok: false, command: 'handoff', why: 'the id from the one line the Claude app gave: hb_ (a build) or hs_ (a setup) and 32 hex digits' };
+  if (!BUILD.test(String(build ?? ''))) return { ok: false, command: 'handoff', why: `the id from the one line the chat gave: hb_ (a build) or hs_ (a setup) and 32 hex digits` };
   const directory = String(homie || studio.homie?.directory || 'https://homie.rocks').replace(/\/+$/, '');
   // lib/net.mjs: through the environment's proxy, and an honest reason when it fails (the directory's own words, or
   // the connection's error; only a refusal by the proxy names the network setting).
@@ -98,7 +100,7 @@ export async function handoff(root, build, { homie, fetchFn = globalThis.fetch,
   };
   let setup = null;
   if (h.setup) {
-    const r = await checkIn(root, h.setup, { homie: directory });
+    const r = await checkIn(root, h.setup, { homie: directory, client: who.id === 'chat' ? null : who.id });
     setup = { ok: r.ok, message: r.ok ? r.message : r.why, renamed: r.renamed ?? [] };
   }
   const taken = await attach(root, { attach: build, what: h.what, id: h.id, directory });
@@ -108,7 +110,7 @@ export async function handoff(root, build, { homie, fetchFn = globalThis.fetch,
     ok: true, command: 'handoff', build, ...h, setup,
     attached: taken.ok ? { feed: taken.build, shared: taken.shared?.build ?? build } : null,
     attachWhy: taken.ok ? null : taken.why,
-    steps: stepsFor(h, { games }),
+    steps: stepsFor(h, { games, client: who.id }),
   };
 }
 

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