@homie-rocks/studio 0.28.0 → 0.29.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.29.0] - 2026-10-03
+
+**Plugin 0.30.0** · [#44](https://github.com/homie-rocks/homie/pull/44)
+
+The Lounge: a community room on your own studio, with play nights, moderators, live rooms and "show what you made" cards, and chat history you can turn on.
+
+### Added
+
+- The Lounge. `"lounge": true` in studio.json gives your studio a community room at `/lounge/`, in your studio's own look: one column of talk on a phone with "What's on" a tap away, the talk beside a sidebar on a computer. It is room chat in a room of its own, on your own Cloudflare: reactions and quick lines for anyone, typing for players signed in with a passkey (Sign in and Make a passkey are on the page itself), and every typed line through the word list and your Workers AI review (Clef) before anyone sees it. Slow mode is 3 s to start with. `chat/LOUNGE.md` has the whole of it.
+- Play nights. Set them in the office (a name, a time in your own zone, how long, a game) or with `homie-studio lounge night "<title>" --at <time>`. Everyone sees the time in their own zone, a countdown, "On now", the game's Play, and Add to calendar (a small `.ics` the browser makes).
+- Live rooms in the Lounge, each with Watch and Join: your studio's own, and with a directory the busiest across it (`"featured": "studio"` keeps it to yours, `"none"` shows none).
+- Show what you made. A signed-in person pastes a link to a game and it becomes a card with the game's own title, pitch, picture and a Play button. Only a Homie studio's game can be one (yours, or a site that answers the studio manifest), its words pass the word list and the review like a typed line, and each person posts three an hour. Typed links stay held.
+- Moderators. Name a player account as a moderator from one of their lines in the office (or `homie-studio lounge mod <player id>`): from the Lounge page they take a line down, mute or kick its sender for up to an hour (their lines come down with them) and set slow mode, never on your lines or another moderator's. You have the same from the page, for up to a day, and everything else in the office's new Lounge section: its rules, play nights, moderators, last lines and reports.
+- Chat history you can turn on (`history`, a number of days, 1 to 90). In the office, "Keep what is said" for the Lounge, or `homie-studio lounge history <days>`; for a game, `"chat": { "history": 7 }` or the office. What is kept, in your studio's own D1: typed lines, quick lines, cards and your own studio lines, the name shown, when, and for a signed-in sender their account id. Never a reaction, an address or a browser key. It is deleted after that many days; keeping fewer days (or none) deletes the rest at once. The room gives kept lines back when it opens ("Earlier messages" pages further), a report still finds an older line, and a mute or kick from a kept line holds its sender's account.
+- Anyone takes their own message down: Delete on their own line in the Lounge (a signed-in person's kept lines too, a guest's while it is in the room's last minutes). Deleting an account at `/account/` deletes every line it kept, and the account's download has them.
+- `homie-studio lounge` (rules, play nights, moderators, last lines, reports), `lounge night`, `lounge history`, `lounge rules`, `lounge mod` and `lounge remove`. From your AI's office key, keeping more days, opening chat up, a new moderator, a mute or a kick only ASK (your one tap); a play night, slow mode, taking a line down and keeping less happen at once.
+- `/lounge/api/now`: the Lounge's public facts (its rules, play nights and live rooms) as JSON, and the studio's manifest names its Lounge. homie.rocks can show a Lounge live when its rules allow it (`hub`): a visitor's own browser opens the Lounge's socket, as for a room's card; they react there and type on your site. The sitemap and llms.txt list the Lounge's page; robots.txt keeps its socket and APIs out.
+- "Get Homie updates" on the setup card (Claude, Claude Desktop and the Claude Code mod): a link to homie.rocks's own sign-up for a short email when Homie ships something. The person signs up there themselves (double opt-in); the card never asks for an address.
+
+### Changed
+
+- Room chat's rules have one more field, `history`. It is 0 for every game and for the Lounge until an owner turns it on, and always 0 on a kids server, a beginner server and a kids Lounge, so nothing changes for a studio that does nothing: a room still keeps the last 50 lines of the last 15 minutes in memory and nothing else.
+- A line on the wire may carry `card`, `mod`, `kept` and, on a page's own copy, `mine`; a page that knows none of them shows the line's words. A watching page may send `unsay` for its own line. The room's facts count watching pages (`counts.shells`). The relay stays revision 8.
+
+### Upgrade notes
+
+- `homie-studio upgrade` adds migration `0009_studio_lounge.sql` (kept chat, play nights, moderators; all empty until you use them) and `npm run deploy` applies it. Nothing else changes until you add `"lounge": true` to studio.json and deploy. A game already called `lounge` keeps its page, and the build says the Lounge is off.
+- Before you turn history on, read `chat/OWNERS.md`: it says what is kept and what that means for children's data. The Lounge's page tells people what is kept, in its "How it works".
+
 ## [0.28.0] - 2026-10-03
 
-**Plugin 0.29.0** · [#43](https://github.com/homie-rocks/homie/pull/43)
+**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)
 ```
 
@@ -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>]
@@ -258,6 +263,7 @@ import { statsKey, statsLink, statsRevoke, statsShare, statsShow } from '../lib/
 import { playersOwner, playersShow } from '../lib/players.mjs';
 import { officeAnnounce, officeClose, officeInvite, officeKey, officeKick, officeLaunch, officeLines, officeLink, officeMute, officeRevoke, officeShow } from '../lib/office.mjs';
 import { chatBudget, chatLines, chatRemove, chatRulesSet, chatShow, chatWords } from '../lib/chat-cli.mjs';
+import { loungeLines, loungeMod, loungeNight, loungeRemove, loungeRulesSet, loungeShow } from '../lib/lounge-cli.mjs';
 import { detectLocalAi, localAiVars } from '../lib/local-ai.mjs';
 import { agentsBrain, agentsBrainKey, agentsPass, agentsPasses, agentsRevoke, agentsTry, serversClose, serversLevel, serversLines, serversList, serversMember, serversNew, serversSet } from '../lib/servers.mjs';
 import { AgentSeat } from '../lib/agent-seat.mjs';
@@ -479,8 +485,13 @@ function print(result) {
       lines.push(result.note);
       break;
     case 'chat remove':
+    case 'lounge night':
+    case 'lounge remove':
       lines.push(result.message);
       break;
+    case 'lounge':
+      lines.push(...loungeLines(result));
+      break;
     case 'shop':
     case 'shop orders':
     case 'shop check':
@@ -498,6 +509,8 @@ function print(result) {
       break;
     case 'chat rules':
     case 'chat budget':
+    case 'lounge rules':
+    case 'lounge mod':
     case 'shop refund':
       lines.push(result.asked ? `Asked: ${result.what}` : result.message, ...(result.asked ? [`Owner's one-tap link (until the ask ends, 15 min): ${result.link}`, result.use] : []));
       break;
@@ -791,6 +804,17 @@ async function main() {
     if (sub === 'close') return officeClose(root, positional[2], positional[3], { url, minutes: flags.get('minutes'), reopen: flags.has('reopen') });
     if (sub === 'revoke') return officeRevoke(root, { url });
   }
+  if (cmd === 'lounge') {
+    // The Lounge (0.29.0, chat/LOUNGE.md): its rules and history, play nights, moderators, lines.
+    const url = flags.get('url');
+    if (!sub) return loungeShow(root, { url });
+    if (sub === 'night') return loungeNight(root, positional.slice(2), flags, { url });
+    if (sub === 'history') return loungeRulesSet(root, flags, { url, history: positional[2] });
+    if (sub === 'rules') return loungeRulesSet(root, flags, { url });
+    if (sub === 'mod') return loungeMod(root, positional[2], { url, remove: flags.has('remove') });
+    if (sub === 'remove') return loungeRemove(root, positional[2], { url, all: flags.has('all') });
+    return { ok: false, command: 'lounge', why: `unknown: lounge ${sub} (night, history, rules, mod, remove)` };
+  }
   if (cmd === 'chat') {
     // Room chat (0.23.0, NETPLAY.md section 19): rules, the room's last minutes, reports, the review's budget.
     const url = flags.get('url');

package/chat/CHAT.md

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

package/chat/LOUNGE.md

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

package/chat/OWNERS.md

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

package/lib/build.mjs

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

package/lib/lounge-cli.mjs

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

package/lib/mcp-tools.mjs

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

package/lib/scaffold.mjs

@@ -30,6 +30,7 @@ import { OFFICE_MIGRATION, OFFICE_MIGRATION_FILE } from '../worker/office-schema
 import { SERVERS_MIGRATION, SERVERS_MIGRATION_FILE } from '../worker/servers.mjs';
 import { CHAT_MIGRATION, CHAT_MIGRATION_FILE } from '../worker/chat-store.mjs';
 import { SHOP_MIGRATION, SHOP_MIGRATION_FILE } from '../worker/shop-store.mjs';
+import { LOUNGE_MIGRATION, LOUNGE_MIGRATION_FILE } from '../worker/lounge-store.mjs';
 import { themeFile } from './site.mjs';
 
 export const COMPAT_DATE = '2026-06-01';
@@ -652,6 +653,7 @@ export { default, Table, Lobby } from '@homie-rocks/studio/worker';
     [`site/migrations/${SERVERS_MIGRATION_FILE}`]: SERVERS_MIGRATION,
     [`site/migrations/${CHAT_MIGRATION_FILE}`]: CHAT_MIGRATION,
     [`site/migrations/${SHOP_MIGRATION_FILE}`]: SHOP_MIGRATION,
+    [`site/migrations/${LOUNGE_MIGRATION_FILE}`]: LOUNGE_MIGRATION,
     'wrangler.jsonc': wranglerConfig({ worker, name, d1: studio.cloudflare.d1, r2: studio.cloudflare.r2, layout: 'root' }),
     '.claude/skills/.gitkeep': '',
   };
@@ -766,13 +768,22 @@ function ensureChatMigration(root) {
   return `site/migrations/${CHAT_MIGRATION_FILE}`;
 }
 
+/** A studio made before 0.29.0 has no Lounge tables: kept chat (only when an owner turns history on), play nights, moderators. */
+function ensureLoungeMigration(root) {
+  const file = join(root, 'site', 'migrations', LOUNGE_MIGRATION_FILE);
+  if (existsSync(file)) return null;
+  mkdirSync(dirname(file), { recursive: true });
+  writeFileSync(file, LOUNGE_MIGRATION);
+  return `site/migrations/${LOUNGE_MIGRATION_FILE}`;
+}
+
 export function ensureMigrations(root) {
-  return [ensureStatsMigration(root), ensurePlayersMigration(root), ensureOfficeMigration(root), ensureServersMigration(root), ensureChatMigration(root), ensureShopMigration(root)].filter(Boolean);
+  return [ensureStatsMigration(root), ensurePlayersMigration(root), ensureOfficeMigration(root), ensureServersMigration(root), ensureChatMigration(root), ensureShopMigration(root), ensureLoungeMigration(root)].filter(Boolean);
 }
 
 /** What a migration file the template added is for, in a few words (deploy and dev say it). */
 export function migrationWord(file) {
-  return /shop/.test(file) ? 'the shop: orders, what players own, refunds and referral books (it sells nothing until shop.json and the owner\'s Stripe key are in)' : /players/.test(file) ? 'player accounts and cloud saves' : /chat/.test(file) ? 'room chat: the owner\'s chat rules and players\' reports (never the chat itself)' : /servers/.test(file) ? 'servers and agent seats: room pools with their own rules, AI passes' : /office/.test(file) ? 'the back office: launch states, invites, the owner\'s controls' : 'the studio\'s own stats: counts, never tracks';
+  return /lounge/.test(file) ? 'the Lounge and kept chat: play nights, moderators, and what was said only where an owner turns history on' : /shop/.test(file) ? 'the shop: orders, what players own, refunds and referral books (it sells nothing until shop.json and the owner\'s Stripe key are in)' : /players/.test(file) ? 'player accounts and cloud saves' : /chat/.test(file) ? 'room chat: the owner\'s chat rules and players\' reports (never the chat itself)' : /servers/.test(file) ? 'servers and agent seats: room pools with their own rules, AI passes' : /office/.test(file) ? 'the back office: launch states, invites, the owner\'s controls' : 'the studio\'s own stats: counts, never tracks';
 }
 
 /**

package/lib/template-history.json

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

package/mcp/ui/setup.js

@@ -60,6 +60,8 @@
     acts.appendChild(C.btn('Check again', 'ghost small', function () {
       C.call('setup_status', { fresh: true }).then(function (r) { C.take(r); }).catch(function () {});
     }));
+    // Homie's own updates by email: the person signs up on homie.rocks (double opt-in); the card asks for nothing.
+    if (sc.updates) acts.appendChild(C.btn('Get Homie updates', 'ghost small', function () { C.open(sc.updates); }));
     foot.appendChild(acts);
     card.appendChild(foot);
     if (install && install.state === 'done') C.tell('install-' + install.job, (cur ? cur.name : 'The studio') + '\'s toolkit finished installing; the studio is ready to build.');

package/netplay/NETPLAY.md

@@ -1230,6 +1230,7 @@ every watching shell. homie.rocks runs nothing: its room page opens the room's o
 | `swears` | `block`, `allow` (`block`) | Slurs, sexual words, threats and contact details are held whatever this says. |
 | `ai` | `true`, `false` (`true`) | The studio's review of typed text. |
 | `bubbles`, `watchers`, `hub` | `true` | A line may show over its sender's character; watchers may send (not only read); homie.rocks's page for the room may show it. |
+| `history` | 0–90 days (0) | 0.29.0: keep what is said (never a reaction) in the studio's D1 for that many days, and give it back as the window when a page opens; 0 keeps nothing past the window. A kids server, a capped room or chat `off` keeps 0. |
 | `emoji` | the five, then up to 3 of the game's own | `{ k, e }`: a kind and its glyph. |
 | `lines` | 8 default lines, or up to 12 of the game's own | `{ id, text }`: the game's words; each passes the floor at build. |
 | `capped` | `kids`, `server-lines`, `server-off` | Why the mode is lower than the game asks. |
@@ -1261,6 +1262,12 @@ stays in the room; clients get the rest in `welcome.policy.chat` and every `poli
 | `lines` | down, a watching shell as it opens | `lines` | The window: the last 50 lines of the last 15 minutes. Never to a page the room holds out. |
 | `unline` | down, everyone | `ids` | The owner took them down: hide them, and their bubbles. |
 | `held` / `slow` | down, the sender | `why`, `message`, `n?`, `until?` | Not sent. `why`: `off`, `emoji`, `lines`, `sign-in`, `sign-in-react`, `members`, `members-react`, `watchers`, `hub`, `muted`, `slow`, `repeat`, `words`, `harm`, `contact`, `link`, `swears`, `ai`, `busy`, `unknown`, `empty`, `ai_seat`. |
+| `unsay` | up, a watching shell | `id` | 0.29.0: take my own line down (a line of this browser, or of this signed-in account). Everyone gets `unline`. |
+
+0.29.0 adds to `line`: `card` (`{ url, title, studio, pitch, image }`, a "show what you made" card the Worker read
+from a Homie studio's manifest; `text` stays a plain fallback such as "Made: <title> by <studio>"), `mod` (a moderator
+the owner named), `kept` (it came from the room's history) and, on a page's own copy of the window only, `mine` (this
+browser's or account's own line). A page that knows none of these shows the line's `text`.
 
 A line's sender is the socket's own client, or for a watch socket the client of the same browser
 (its room key) or account in the room: its seat, name and colour. A page with no client in the
@@ -1361,7 +1368,10 @@ ticker.
 
 **Privacy.** Nothing a person says is stored: the room keeps the last 50 lines of the last 15
 minutes in its memory (never in Durable Object storage), and an empty room forgets them with
-everything else a minute after its last person leaves. The counts (lines, reactions, held by why,
+everything else a minute after its last person leaves. Only where the owner turns `history` on (0.29.0; off by
+default for every game and the Lounge, never on a kids server) does the Table keep what was said in D1
+(`chat_history`: the words, the name shown, when, a signed-in sender's account id; never a reaction, an address or a
+browser key) for that many days; what is taken down there is deleted there, and a deleted account takes its lines. The counts (lines, reactions, held by why,
 reviews and neurons) are daily numbers in the studio's own D1, never a message or a sender. A
 report keeps one message for 30 days. The review sends the message's words (and nothing about who
 said it) to the studio's own Workers AI; Cloudflare says it does not keep or train on them.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homie-rocks/studio",
-  "version": "0.28.0",
+  "version": "0.29.0",
   "description": "A studio for games, music and video on its own Cloudflare: scaffold, multiplayer starters on the netplay contract, a port toolkit that makes existing single-player web games multiplayer, the site Worker with public rooms (Table/Lobby Durable Objects and D1, all on the free Workers plan, no payment method), a site with the hub's sections (Home, Games, Music, Videos, Rooms, Posts with feeds) in the studio's own look, an epic landing page for every game, big songs and videos in the studio's own R2 once it has storage (uploaded, checked by SHA-256, served at the same addresses), deploy, and the homie.rocks directory.",
   "type": "module",
   "license": "Apache-2.0",

package/site/SITE.md

@@ -13,6 +13,7 @@ and every game gets a landing page. Anything the studio puts in `site/` wins.
 | `/music/`, `/videos/` | Songs and videos (`media/MEDIA.md`) | the studio has one published |
 | `/rooms/` | Every public room playing now across the studio's games, each with Join (`/api/rooms` is the same as JSON, cacheable for 15 s) | the studio has a game |
 | `/posts/` | The studio's posts, newest first, with `/posts/feed.xml` (Atom) and `/posts/feed.json` (JSON Feed) | the studio has a post |
+| `/lounge/` | The Lounge (0.29.0): the studio's community room, with play nights, live rooms and "show what you made" (`chat/LOUNGE.md`) | studio.json has `"lounge"` |
 
 A section with nothing in it has no tab, and its address answers 404. Every page ends with a
 "Made with Homie" link to https://homie.rocks/studio/. studio.json may add `"tagline"` (one line, on Home and in
@@ -35,6 +36,18 @@ the hub offers Watch beside Join. From 0.23.0 a room whose chat is on and whose
 socket from the visitor's browser and shows its lines and reactions live (NETPLAY.md section 19). A visitor there
 sends what a watcher may send (reactions and quick lines when the room's `react` is `anyone`), never types.
 
+## The Lounge: `/lounge/` (0.29.0)
+
+With studio.json `"lounge": true` (or `{ "name", "tab", "blurb", "featured", "kids", "chat" }`), `/lounge/` is the
+studio's community room (worker/lounge.mjs, lounge-page.mjs; chat/LOUNGE.md): room chat in a room of its own, in the
+studio's look, one column on a phone ("Chat" and "What's on") and the talk beside a sidebar on a computer. Its script
+is `/_homie/lounge.js`; its socket is `/lounge/__watch` (a page of this site carries its signed-in account; a page of
+another site is a watcher that reacts, never types). `/lounge/api/now` is its public facts as JSON (rules, play
+nights, live rooms; CORS open, cacheable for 30 s), and the manifest names it (`lounge: { name, page, now }`).
+`/lounge/api/history`, `show`, `report`, `delete` and `mod` are this site's pages' only. The owner's tools are
+`/_studio/api/lounge` and `/_studio/api/lounge/rules`, `night`, `mod`, `remove` and `hold`. A game called `lounge`
+keeps its page, and the build says the Lounge is off.
+
 ## Room chat on the play, watch and TV pages
 
 Every play page, big screen and watch page carries room chat (worker/chat-page.mjs; chat/CHAT.md): the Chat pill