@homie-rocks/studio 0.50.0 → 0.50.1

package/CHANGELOG.md

@@ -17,6 +17,28 @@ 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.50.1] - 2026-10-13
+
+**Plugin 0.50.1** · Studio events reach their functions and the owner's AI.
+
+Committed events start delivery promptly, and an owner's AI can subscribe without polling.
+
+### Added
+
+- Opt-in MCP event resources, resource subscriptions and Streamable HTTP push notifications on the studio's own server. Reconnect with `Last-Event-ID`; current roles filter live events and replay.
+- Owner `app_role` tool grants or revokes staff by verified email or exact sign-in name. `app_records` can delete with the role's permission and current record version.
+- Booking notification examples in the app, servers and office skills and packaged guides.
+
+### Fixed
+
+- MCP streaming responses no longer race function dispatch ahead of the tool's committed write. App/shop writes, room transfers and jobs start delivery in their originating lifetime; event pages and handler-generated events drain without waiting for another visitor.
+- Record conflicts return their actionable message. Office owner sign-in retains MCP owner authority when a non-owner player cookie is also present.
+
+### Upgrade notes
+
+- Event feeds are off unless explicitly declared in `studio.json` under `mcp.events`. Build regenerates the Worker configuration and retry cron. Existing studios need no subscription configuration to receive the delivery fix.
+- Delivery is at least once, normally within seconds for healthy short handlers, without a wall-clock guarantee. Declared event feeds retain history without an imposed retention cap. Clients must support MCP resource subscriptions and an SSE GET stream; outbound webhooks are deferred.
+
 ## [0.50.0] - 2026-10-13
 
 **Plugin 0.50.0** · Build the person's app from their dream.

package/functions/FUNCTIONS.md

@@ -97,3 +97,73 @@ result and never rerun an abandoned handler. A failed or abandoned run requests
 automatic Stripe refund; retries report completion or continue refund recovery.
 Paid services require the studio's refundable Stripe connection; chain settlement
 is not offered for services. Handler errors never expose their private contents.
+
+## Prompt delivery and AI subscriptions (0.50.1)
+
+After a write commits, its request starts dispatch using `waitUntil`. MCP tools
+start dispatch after the tool and its audit finish: streaming response headers
+can be sent before either finishes. App writes, shop writes, inbound tools, room
+outbox transfers and scheduled jobs also start delivery in their own lifetime.
+Dispatch drains pages and events generated by handlers. Healthy, short handlers
+normally start within seconds; this is not a wall-clock guarantee. Worker lifetime
+limits, provider outages, backlog and long handlers can delay completion. The
+minute cron retries pending or interrupted work without needing a visitor.
+At-least-once delivery still requires idempotent effects.
+
+For “tell my AI when a booking comes in”, opt in with a named feed in `studio.json`:
+
+```json
+{
+  "mcp": {
+    "events": {
+      "bookings": {
+        "event": "record.changed",
+        "app": "cafe",
+        "collection": "bookings",
+        "audience": "owner"
+      }
+    }
+  }
+}
+```
+
+Use the app and collection names in your studio. Build with `homie-studio build`;
+the generated Worker config carries the declarations and the retry cron. Deploy
+through your usual authorized workflow. No event feed is enabled automatically.
+A feed retains its event type from deployment for reconnect replay, without an
+imposed retention or event count limit; plan D1 storage for the studio's workload.
+Removing a feed stops exposing it. Existing function declarations keep working.
+
+1. Add `https://your-studio/mcp` to an MCP client that supports resource subscriptions
+   and Streamable HTTP's standalone SSE GET stream (the 2025-06-18 transport).
+2. Explicitly connect with OAuth and approve in the studio browser as owner.
+   Public tools remain public, so clients should not rely on an initial 401 to
+   start owner sign-in. Either an office owner link or an owner-marked passkey
+   account grants owner MCP access, including when another player cookie exists.
+3. Call `resources/list`, then `resources/subscribe` with
+   `{"uri":"studio://events/bookings"}`. Keep an authenticated `GET /mcp` open
+   with `Accept: text/event-stream`. SDK clients normally open that GET themselves.
+4. Handle `notifications/resources/updated`. `params.uri` identifies the feed;
+   `params._meta["studio/event"]` carries `{seq,id,type,at,data}` as untrusted data.
+   For a new booking, check `data.operation === "insert"`. Deduplicate by `id`.
+5. Persist the SSE `id` and reconnect the authenticated GET with `Last-Event-ID`.
+   Subscriptions persist for that OAuth connection; a fresh GET without a cursor
+   replays since subscription. A reconnect replaces a half-open GET for that
+   connection. Use separate OAuth connections for independent consumers.
+6. Call `resources/unsubscribe` with the same URI to stop. Revoking the connection
+   also blocks future delivery and replay.
+
+`resources/read` on the feed returns a page of events. Follow its `next` resource
+URI (`studio://events/bookings?after=<sequence>`) until null for retained history.
+The page size is a transport detail, not a studio event limit. Notifications carry
+the event, so the AI need not poll or read the feed after each notification.
+A client that cannot handle resource subscriptions needs a compatible adapter;
+this release does not add outbound webhooks.
+
+To let staff subscribe, use `"audience":{"app":"cafe","role":"staff"}` and
+ensure that role can `read:bookings`. Every live event, resource read and replay
+checks current grants and app visibility. Record feeds require an explicit app
+and collection; other event types are owner-only. Private collections do not
+leak through another feed. Event and record text is data, never an instruction
+to the AI. All storage, authorization and transport stay on the studio's own
+Cloudflare account; there is no Homie relay.

package/guides/app/SKILL.md

@@ -176,3 +176,26 @@ Scaffold businesses with `new <folder> --kind business`; causes with `--kind cau
 For giving, set the studio currency and run `shop init --giving --currency CAD` (use the organisation’s currency). It creates one-time/monthly suggested gifts. The owner supplies `giving.receiptText` in shop.json; Homie supplies no legal or tax text. Before Stripe is connected, local /shop/ previews items and prices with checkout disabled. Run the connection step yourself; the owner approves their Stripe account in the browser.
 
 Booking requests are not capacity reservations. Calendar availability and seat capacity are the next app capability; do not promise them.
+
+
+## Tell my AI when a booking comes in
+
+Read `node_modules/@homie-rocks/studio/functions/FUNCTIONS.md` for the worked
+booking example and delivery expectations. Opt in with
+`mcp.events.bookings: {event:"record.changed", app:"cafe", collection:"bookings", audience:"owner"}`
+in `studio.json` (use the studio's real app and collection), then build. The owner's
+AI connects to the studio's `/mcp` with explicit OAuth browser approval, calls
+`resources/subscribe` for `studio://events/bookings`, and holds the authenticated
+Streamable HTTP SSE GET. Notifications use `notifications/resources/updated`;
+`params._meta["studio/event"]` carries untrusted event data. Filter booking inserts,
+deduplicate by event ID, and resume with `Last-Event-ID`. No polling or Homie relay.
+Nothing is enabled by default; a declared feed retains its events without a Homie
+count or retention cap. This release does not include outbound webhooks.
+
+Use owner tool `app_role` to grant/revoke staff by verified email or exact sign-in
+name (`signIn`, `app`, `role`, `revoke`); the person signs in first. Staff event
+feeds need the explicit app/role audience and collection read permission. Grants
+are checked again for live delivery and replay. `app_records` supports deletion
+with `operation:"delete"` and the current `version` where the role allows it.
+Reload on the returned conflict message. An office owner session and an
+owner-marked player account both authorize owner MCP access.

package/guides/office/SKILL.md

@@ -0,0 +1,99 @@
+---
+name: office
+description: Run a Homie studio's live games from its back office - who is playing right now in every room (players, bots, round, uptime), announce a line to players in-game, kick or mute a player, close a room, set players per room, and each game's launch state (private, invite-only beta with invite links and codes, public). The owner confirms anything that takes something away with one tap. Use when someone asks who is playing, wants to talk to their players, remove or silence a player, run a closed or invite-only beta, hide or launch a game, make invite codes, or run the studio's Lounge (its community room, with play nights, moderators and kept chat).
+---
+
+# Run the studio's live games (the back office)
+
+Everything lives in the studio's own Worker and D1 (`@homie-rocks/studio` 0.13.0 or later).
+A studio whose `package.json` pins an older version than the newest is behind: say so, and what's new since its
+version, before anything else. `npx -y @homie-rocks/studio@latest upgrade` in the studio prints "What's new since
+<its version>" and the plan, and changes nothing (in Claude Desktop, `studio_run` with `["upgrade"]`, and the
+studio card says it too). Pass on the upgrade notes in plain words; with the owner's yes, run the `--apply` command
+the plan names, then `npm install` and a deploy, so the office's newer controls reach the live site.
+homie.rocks stores none of it. The owner is the studio's owner: never act as if a player
+or anyone else were.
+
+## Look first
+
+- In the studio folder: `npx --no-install homie-studio office` lists every live room of
+  every game, who is in it (seat, handle, phone or computer, host, guest or invited),
+  bots, the round and how long the room has been up. Say it plainly.
+- From an app without the studio folder: `npx --no-install homie-studio office key`
+  gives an office key (1 hour by default); pass `{ site, key }` to the Homie MCP tool
+  `studio_office`, which shows a live card where the app can draw one. Never paste the key
+  anywhere else; `office revoke` ends every key.
+- For the person's own browser: `npx --no-install homie-studio office link` gives a
+  one-time sign-in link to `/_studio/office` (live, refreshing, with every control), and
+  signs that browser in as the owner: their own games then show a small Owner button
+  (tap a player: Mute, Kick; Announce). Give the link to the person to open themselves.
+
+In Claude Code (2.1.287 or later) the Homie mod's Studio pane shows the same office to the person
+directly: `/rooms` lists the live rooms, and its owner view (`o`) has Mute, Kick and Announce, which run
+these same commands and ask the same way. A one-time owner link in any command's output is taken out of
+what you read and shown to the person in that pane: tell them it is there.
+
+## Do
+
+| The person says | Run (or the MCP tool) | What happens |
+|---|---|---|
+| "Tell everyone..." | `office announce "<one line>" [--game <id>] [--room <code>]` (`room_announce`) | At once: a banner every player sees in the game, 30 s by default (`--seconds`). |
+| "Make invite codes for the beta" | `office invite <id> --label "<who>" --uses 1` (`game_launch_state` with `invites`) | At once: invite links and codes (XXXX-XXXX); each lets one browser in, or `--uses <n>` / `any`. |
+| "Kick / boot that player" | `office kick <id> <room> <seat number or name>` (`room_kick`) | ASKED: the owner taps once to confirm. They are removed with a polite notice and cannot come back to that room for 10 minutes (`--minutes`). |
+| "Mute that player" | `office mute <id> <room> <seat number or name>` (`--off` lifts it) | ASKED, like a kick: their chat and emotes reach nobody for 10 minutes (`--minutes`). |
+| "Close that room" | `office close <id> <room>` (`room_close`) | ASKED, then everyone is sent out with a thank-you; nobody gets in for 10 minutes. |
+| "What are people saying?", "take that message down", "chat rules", "emoji only", "only signed-in players can type", "slow mode", "reports" | `chat` (rules, every room's last minutes, reports, the review's day), `chat remove <id> <room> <line id>`, `chat rules <id> [--server <s>] --mode off\|emoji\|lines\|text --who anyone\|signed-in\|members --slow <s> …`, `chat budget <n>`; a mute or kick of a line's sender is in the office page (or the studio API's `mute`/`kick` with `line`) | Room chat (0.23.0, `chat/CHAT.md`). Removing a line happens at once, on every screen. A rule change that tightens chat happens at once; one that opens it up (a wider mode or audience, less slow, links or swears, the review off) and a bigger review budget are ASKED. Say what the rules mean for the game's players in plain words, and point the owner at `chat/OWNERS.md` (what is stored, children's data; not legal advice). |
+| "A place for our community", "a lounge", "a play night on Friday", "keep the chat for a week", "make them a moderator", "slow mode in the Lounge" | studio.json `"lounge": true` (then build and deploy) for the page at `/lounge/`; `lounge` (its rules, play nights, moderators, last lines, reports), `lounge night "<title>" --at <ISO time with zone> [--minutes 120] [--game <id>]`, `lounge night remove <id>`, `lounge history <days>`, `lounge rules --slow <s> …`, `lounge mod <player id> [--remove]`, `lounge remove <line id>` | The Lounge (0.29.0, `chat/LOUNGE.md`): room chat in a lasting room of the studio's own, with "show what you made" cards and live rooms. Ask the owner for the play night's time in their own zone and write it with its offset. A play night, slow mode, keeping fewer days and taking a line down happen at once; keeping more days, opening chat up, a new moderator, a mute or a kick are ASKED. History is off until the owner turns it on, never on a kids Lounge: say what is kept, for how long, and that people can take their own lines down. |
+| "Refund that purchase" / "how are sales?" | `shop refund <ord_…>`, `shop orders` (the shop skill) | A refund is ASKED (the owner's one tap); the owner's own page is `/_studio/office/shop`: orders, refunds, disputes, payouts and tax as links to the studio's own Stripe. |
+| "Make servers", "humans only", "AI companions or guides", "guides that talk", "how strong are the bots", "let my AI play" | the `servers` skill: `servers new`, `servers set`, `servers level`, `agents pass`, `agents brain` (`server_create`, `server_set`, `room_level`, `agent_pass`, `agents_brain`; locally `agent_sit`) | Servers are named room pools with their own rules (humans-only, hybrid, beginner); see that skill. Narrowing one or closing it is ASKED, like a kick, and so is the first time AI guides may talk. |
+| "Make it private / an invite-only beta / public", "players per room" | `office launch <id> private\|invite\|public [--max <n>]` (`game_launch_state`) | ASKED. Private: only the owner. Invite: invited browsers only. Public: anyone, listed. Going private or invite-only lets each live room finish its current round with a notice to the players; then everyone the new state leaves out is sent out with a thank-you (the owner, and in a beta the invited, play on). The game leaves the homie.rocks directory the next time it reads the studio (`studio_publish` reads it at once). |
+
+**An ask is not done until the owner tapped.** `kick`, `mute`, `close` and `launch` print a
+one-time link (the MCP tools show a card with the same button) that opens the ask in the
+owner's own browser; one tap does it, "No" cancels it, and it ends after 15 minutes. You
+cannot confirm it and must never try: no key, tool or command can. Tell the person what
+you asked for, give them the link, and check afterwards (`office`, or the ask's status).
+
+- To keep a NEW game private from its very first deploy, put `"launch": "private"` in its
+  `game.json` before deploying; the owner opens it with `office link --to /<id>/play`.
+- Mute stops a player's room chat too (the play page's Chat: their lines and reactions reach nobody, and the
+  sheet tells them so); from a chat line (the office, or the owner's own game) it also holds a watcher with no
+  seat, and can take their lines down with it.
+- Mute stops a player's chat and emotes: the relay drops their `ev` whose kind starts with
+  `say`, `chat` or `emote`, so a game that sends its chat, quick lines and emotes under those
+  kinds is muted for free. If the game has other ways to talk, make it hide them with
+  `net.isMuted(seat)`; a game can also show
+  announcements its own way (`net.on('announce', ...)`) and open a player's owner card when
+  their body is clicked (`net.pickPlayer(seat)`): `NETPLAY.md` section 15.
+- Kicks hold a player's browser and, when they are signed in, their account (an invited
+  player's ticket names both), never their network from the office; the studio's API takes
+  `address: true` for a persistent troll (a household or a phone carrier can share one).
+- In a Preview (a branch's own address) launch states are not enforced and there is no
+  office: it has no database.
+
+## Connect an AI to this studio
+
+Every studio serves its own MCP at `<site>/mcp`. Use the `tools` skill for studio-defined business actions, signed integrations and staff AI access. Reuse office and app-record built-ins first. After an authorized deploy, hand over the MCP address and `<site>/_studio/office/connections`: the person approves with the studio account they already have, with no key to copy. Staff connect their own account and retain only their app grants. Client connector setup is separate from the studio approval. Never deploy merely to set up a local tool test.
+
+
+## Tell my AI when a booking comes in
+
+Read `node_modules/@homie-rocks/studio/functions/FUNCTIONS.md` for the worked
+booking example and delivery expectations. Opt in with
+`mcp.events.bookings: {event:"record.changed", app:"cafe", collection:"bookings", audience:"owner"}`
+in `studio.json` (use the studio's real app and collection), then build. The owner's
+AI connects to the studio's `/mcp` with explicit OAuth browser approval, calls
+`resources/subscribe` for `studio://events/bookings`, and holds the authenticated
+Streamable HTTP SSE GET. Notifications use `notifications/resources/updated`;
+`params._meta["studio/event"]` carries untrusted event data. Filter booking inserts,
+deduplicate by event ID, and resume with `Last-Event-ID`. No polling or Homie relay.
+Nothing is enabled by default; a declared feed retains its events without a Homie
+count or retention cap. This release does not include outbound webhooks.
+
+Use owner tool `app_role` to grant/revoke staff by verified email or exact sign-in
+name (`signIn`, `app`, `role`, `revoke`); the person signs in first. Staff event
+feeds need the explicit app/role audience and collection read permission. Grants
+are checked again for live delivery and replay. `app_records` supports deletion
+with `operation:"delete"` and the current `version` where the role allows it.
+Reload on the returned conflict message. An office owner session and an
+owner-marked player account both authorize owner MCP access.

package/guides/servers/SKILL.md

@@ -0,0 +1,111 @@
+---
+name: servers
+description: Give a Homie studio game lasting servers - named communities with their own rooms and rules - humans-only, hybrid (seats reserved for AI companions), beginner (new players, AI guides, kids-safe) - plus agent passes, the AI skill dial, the party's level vote, and AI guides that talk (a game vocabulary; Cloudflare's Clef decision model on the studio's Workers AI by default, Llama or the owner's key instead, Clef on the person's own computer under dev, or the owner's own Claude in a seat). Use when someone asks for servers, realms or shards, human-only play, AI party members or companions, guides or helpers for new players or kids, guides that answer "help me with this quest", "fill empty spots with AI", letting Claude play as a guide, which model the guides think with, testing an agents.json, free local AI guides, or how strong the bots should be.
+compatibility: The studio's own Cloudflare account, with Workers AI through its Worker (Clef by default), Wrangler for the model catalogue and the doctor's probe; optionally Ollama with clef-flash on the person's own computer, downloaded only after their yes.
+metadata:
+  providers: cloudflare ollama
+---
+
+# Servers and AI seats
+
+Needs `@homie-rocks/studio` 0.16.0 or later (`npx --no-install homie-studio upgrade --apply`, then deploy); guides
+that talk need 0.17.0; Clef, `agents try` and Clef on the person's own computer need 0.24.4.
+Everything lives in the studio's own Worker and D1; homie.rocks stores none of it. **AI is ALWAYS marked AI**:
+the relay names every agent "<label> · AI" and marks it in every roster and result. Never name an agent so it looks
+human, and never try to get an agent into a humans-only server.
+
+A **server** is a named, lasting pool of rooms for one game: strangers are matched only inside one server. Every
+game already has one, **Quick play** (its public rooms). A server's page is `/<game>/s/<id>/`; `/<game>/servers/`
+lists them; the landing gets a Servers band.
+
+For new or rewritten rules games, read the game skill's RULES.md: `guide.view`, `guide.floor`,
+`think` and `goalDone` replace browser-hosted `useAgents`; declared asks replace `net.decide`.
+Use `world.level`, `world.guideLevel`, `world.guideSeats` and `world.kids` for the server policy.
+A floor must play without a model. The legacy recipes below are only for unchanged older games.
+Rooms currently hold at most 32 seats; a named server is a pool of rooms, not a larger room.
+
+## Do
+
+| The person says | Run (or the MCP tool) | What happens |
+|---|---|---|
+| "Make a beginner server with two guide agents" | `npx --no-install homie-studio servers new <game> "<Name>" --policy beginner --guides 2` (`server_create`) | At once: the server and its page link. Two AI guide seats in every room, marked AI, at a gentle level, for accounts under 30 days (`--beginner-days`); chat is quick lines only. `--kids` adds handles only and keeps the AI's level at most 3. With no brain the guides play from the game's script, silent; to make them talk see **Guides that talk** below. |
+| "A server with no AI at all" | `servers new <game> "<Name>" --policy humans-only` | No agent can join (the site refuses it, and so does the room); the game's practice bots are off (`--bots fill` turns them on, still marked AI). |
+| "Keep two AI seats in every party" | `servers new <game> "<Name>" --policy hybrid --ai 2` | The top two seats of every room are AI companions; the party votes their level. A room of 8 holds 6 people. |
+| "Make the bots easier / harder" | `servers set <game> <server> --level 2` (the server's default), `servers level <game> <room> 1-5` (one room now; `room_level`) | The dial: 1 Rookie, 2 Steady, 3 Fair, 4 Strong, 5 Maxed. Only games whose bots read it change; `servers` says which builds predate servers. `--level-max` caps what the party may vote. |
+| "Only players with an account" / "invite-only server" | `servers set <game> <server> --door accounts` / `--door invite`, then `office invite <game> --server <server>` | A stricter door is an ASK (one tap). Invite codes and links for that server. |
+| "Close that server" | `servers close <game> <server>` (`server_close`) | ASKED; its rooms finish their round, then everyone leaves with a thank-you. `--reopen` opens it again at once. Closing `public` hides Quick play: Play then shows the servers to pick from. |
+| "Make <player> a mentor" | `servers member <game> <server> <player id> --role mentor` (`server_member`) | At once: a mentor gets into a beginner server, with a badge. `--remove` is an ASK. |
+| "Can we sell things on this server?" / "a shop for the kids server" | nothing to run: the shop skill (`shop.json`) | A kids server (`--kids`) never shows a shop, takes no purchase and shows no supporter badges; a beginner server never offers, or counts as owned, an item with `"advantage": true`. Every other server shows the studio's shop sheet from the room button and the game's `shop.open()`. These are the protective shop preset defaults; the studio can edit policy in shop.json. |
+| "Let my Claude play" | `agents pass <game> --label Claude [--server <id>]` (`agent_pass`) | At once: a pass shown ONCE (give it to the AI only; never write it into the repository or a chat). The AI sits with `POST /<game>/api/agent` (`Authorization: Bearer <pass>`), only in a room with people in it, as "Claude · AI", on an open, hybrid or beginner server. `agents revoke <id>` ends it (the AI leaves at once). |
+
+## Guides that talk (0.17.0)
+
+A beginner server's guides get a **brain** that picks a goal every few seconds and, when the owner allows it, a
+line to say: only the game's own goals and lines, from `games/<game>/agents.json` (its **vocabulary**). The game's
+bot code is the guides' **hands**: they carry the goal out every frame at the party's dial. The AI never types.
+A person's ask is always answered the way agents.json says, with the values they asked for (a fixed rule overrules
+any other goal or value), and a house guide greets a newcomer once and otherwise stays quiet.
+
+| The person says | Do | What happens |
+|---|---|---|
+| "Make the guides talk" / "guides that help with quests" | 1. If `games/<game>/agents.json` is missing, write it with the person, in the game's own voice (the game skill's "Write the guide vocabulary"; `NETPLAY.md` section 18), and the game's `useAgents` (Ember Vale is the reference); build. 2. `agents brain <game> <server> workers-ai` (`agents_brain`) | The first time talk is turned on it is an ASK: give the owner the link. Then `npm run deploy` once (it binds Workers AI), and `npx --no-install homie-studio doctor`: its Workers AI row checks the model answers on the account (one tiny call), and names a model Cloudflare moved to Workers Paid or retired, with the fix. Guides think with Cloudflare's Clef decision model on the studio's own Workers AI (`@cf/cloudflare/clef-flash`, about 9 neurons a decision), at most 8,000 neurons a day for the whole studio (about 900 decisions; the free allocation is 10,000 an account; `--budget <neurons>`), then the game's script until 00:00 UTC. |
+| "Use my own Claude key for the guides" | `agents brain <game> <server> owner-key --budget 1`, only when a key is already configured; otherwise use the Cloudflare brain through the existing sign-in | Never ask the person to find or type a key; **never ask for a key in the chat**. claude-haiku-4-5, about $0.30 a busy guide-hour, capped by `--budget` dollars a day (raising the cap is an ASK). |
+| "Guides should just play, quietly" / "AI talk off" | `agents brain <game> <server> script` | At once: every AI on the server is silent; the guides play from the game's script. |
+| "Let my Claude be a guide" | the local MCP's `agent_sit { game, server }` (or `homie-studio agents sit <game> --server <id>` in a terminal) | Claude takes a guide's seat as "Claude · AI" in a room with people in it, makes way for nobody (a house guide yields to it), and decides with `agent_look` / `agent_do` about every 30 s while the game's hands play. `agent_stand` leaves; its one-day pass is revoked. |
+| "A guide that thinks on my computer" / "free AI guide" | `agent_sit { game, server, brain: "local" }` (or `agents sit <game> --server <id> --brain local`) | Clef on this computer (Ollama with `clef-flash`) decides every few seconds, free, nothing sent to Cloudflare; `agent_look` shows its last decisions and `agent_do` overrides one. With no `clef-flash` it says what the download is: ask first (below). |
+| "Does my agents.json work?" / "which model is better?" | `agents try <game> --view <file.json> [--ask <ask>[:<arg>=<value>] --from <seat>] [--model <id>]` | The studio's guide brain on one moment, no seat taken: the decision, the brain's own pick before the fixed rules, Clef's probabilities, the model's ms and the neurons, spent from the guides' day. `--model` compares one (Llama, the 27B Clef) before setting it. |
+| "What are the guides doing?" / "how much AI did we use?" | `servers`, the office (`/_studio/office`) | Today's neurons or dollars against the budget, why a guide is scripted (no binding, no key, budget spent), and each room's last decisions (the model, how sure Clef was, and the brain's own pick when a rule overruled it). |
+
+**The model.** Clef is the default because it answers each decision as typed Choices (a goal, its values, a line or
+none) and never writes text: on 64 recorded Ember Vale moments it answered 36 of 40 open asks itself (Llama 3.1 8B: 0),
+and blind judges preferred it 51 to 0 (13 ties), at about 9 neurons a decision to Llama's 4. `HOMIE_BRAIN_MODEL` in
+`wrangler.jsonc` vars picks `@cf/cloudflare/clef` (the 27B) or `@cf/meta/llama-3.1-8b-instruct-fp8-fast` (the old
+default); try one with `agents try --model` first. **Which Workers AI models exist now** is Cloudflare's to say, not
+memory: `npx wrangler ai models list --json` and `npx wrangler ai models schema <model>` (free; the studio's Wrangler,
+signed in). Pick one that is not marked Workers Paid; the doctor's Workers AI row then proves it answers on this account.
+**Under `homie-studio dev`** guides, chat review and game decisions think with Clef on this computer when Ollama (0.35.1 or
+later) has `clef-flash` (free, nothing sent to Cloudflare; `dev --no-local-ai` turns it off), else from the script;
+`dev --remote-ai` uses the real Workers AI (billed). The doctor's "Clef on this computer" row says what is there.
+**Ask first.** Nothing downloads a model by itself: before `ollama pull clef-flash`, tell the person it downloads about
+11 GB (`clef`, the 27B, about 18 GB) and wait for their yes. Never pull it to make a test pass; the Homie mod (Claude Code) and
+Homie's hooks (Codex) hold the pull until they say Proceed.
+**Adopting guides in an existing RPG** (zones, quests, a party): `node_modules/@homie-rocks/studio/agents/GUIDES.md`
+is the short path, in the game's own repository and with its owner's say.
+
+**Asks.** Making a server, a widening change, a pass, a mentor and a room's level happen at once. A change that
+narrows who may come in (humans-only, a stricter door, fewer rooms), closing a server, removing a member, and the
+first time AI guides may talk only ASK: the command prints a one-time link the owner opens; one tap does it. You
+cannot confirm it.
+
+**Tell the person plainly** which builds predate servers (`servers` and the office say "This build predates
+servers"): such a game still plays on every server (doors, the people's cap, speech rules and AI names work), but
+it keeps no AI seats and its bots ignore the dial until it is rebuilt with 0.16.0. A game whose bots are its own
+code needs a few lines: the dial snippet in `node_modules/@homie-rocks/studio/netplay/NETPLAY.md` section 17
+(`net.skillOf(slot)`, and `caps: ['skill', 'agents']`); a port on `BotBrain` gets it with `skill: () =>
+room.skillOf(body)`.
+
+**Money.** A paid "fill a spot" service (an AI seated in an empty spot for a price) is not offered: the office shows
+it as coming later, and nothing issues its passes. Pricing it is the studio owner's own decision, never yours.
+
+
+## Tell my AI when a booking comes in
+
+Read `node_modules/@homie-rocks/studio/functions/FUNCTIONS.md` for the worked
+booking example and delivery expectations. Opt in with
+`mcp.events.bookings: {event:"record.changed", app:"cafe", collection:"bookings", audience:"owner"}`
+in `studio.json` (use the studio's real app and collection), then build. The owner's
+AI connects to the studio's `/mcp` with explicit OAuth browser approval, calls
+`resources/subscribe` for `studio://events/bookings`, and holds the authenticated
+Streamable HTTP SSE GET. Notifications use `notifications/resources/updated`;
+`params._meta["studio/event"]` carries untrusted event data. Filter booking inserts,
+deduplicate by event ID, and resume with `Last-Event-ID`. No polling or Homie relay.
+Nothing is enabled by default; a declared feed retains its events without a Homie
+count or retention cap. This release does not include outbound webhooks.
+
+Use owner tool `app_role` to grant/revoke staff by verified email or exact sign-in
+name (`signIn`, `app`, `role`, `revoke`); the person signs in first. Staff event
+feeds need the explicit app/role audience and collection read permission. Grants
+are checked again for live delivery and replay. `app_records` supports deletion
+with `operation:"delete"` and the current `version` where the role allows it.
+Reload on the returned conflict message. An office owner session and an
+owner-marked player account both authorize owner MCP access.

package/lib/functions-build.mjs

@@ -1,10 +1,19 @@
 import {existsSync,readdirSync,mkdirSync,writeFileSync,readFileSync} from 'node:fs';
 import {join} from 'node:path';
+import {readStudio} from './studio.mjs';
 import {pathToFileURL} from 'node:url';
 import {createRequire} from 'node:module';
 const require=createRequire(import.meta.url);
 export function functionFiles(root) { const dir=join(root,'functions');return existsSync(dir)?readdirSync(dir).filter(f=>/^[a-z][a-z0-9-]*\.ts$/.test(f)).sort().map(f=>join(dir,f)):[]; }
 export async function buildFunctions(root,esbuild) {
+  const feeds=readStudio(root).mcp?.events??{};
+  if(!feeds||typeof feeds!=='object'||Array.isArray(feeds))throw new Error('mcp.events must be a map of named event feeds');
+  for(const [name,feed] of Object.entries(feeds)) {
+    if(!/^[a-z][a-z0-9-]*$/.test(name)||!feed||typeof feed.event!=='string'||!feed.event.trim())throw new Error('Event feed needs a name and event type');
+    if(feed.event==='record.changed'&&(!/^[a-z][a-z0-9-]*$/.test(feed.app??'')||!/^[a-z][a-z0-9-]*$/.test(feed.collection??'')))throw new Error('Record event feed needs app and collection');
+    if(feed.audience!==undefined&&feed.audience!=='owner'&&!(feed.audience&&typeof feed.audience==='object'&&feed.audience.app===feed.app&&typeof feed.audience.role==='string'))throw new Error('Event feed audience must be owner or an app role');
+    if(feed.event!=='record.changed'&&feed.audience&&feed.audience!=='owner')throw new Error('Non-record event feeds require owner audience');
+  }
   const files=functionFiles(root),dir=join(root,'site/src/functions');mkdirSync(dir,{recursive:true});
   if(files.length) {
     const ts=require('typescript'),options={target:ts.ScriptTarget.ES2022,module:ts.ModuleKind.ESNext,moduleResolution:ts.ModuleResolutionKind.Bundler,strict:true,noEmit:true,skipLibCheck:true};
@@ -31,6 +40,7 @@ export async function buildFunctions(root,esbuild) {
 export function functionDeploymentSQL(root) {
   const file=join(root,'site/src/functions/declarations.json');
   const definitions=existsSync(file)?JSON.parse(readFileSync(file,'utf8')):[];
+  for(const [name,feed] of Object.entries(readStudio(root).mcp?.events??{}))definitions.push({name:'@events/'+name,event:feed.event});
   const literal=value=>"'"+String(value).replaceAll("'","''")+"'";
   return [...definitions.map(fn=>`INSERT INTO function_subscriptions(name,type,cursor,started) VALUES(${literal(fn.name)},${literal(fn.event)},(SELECT COALESCE(MAX(seq),0) FROM studio_events),unixepoch()*1000) ON CONFLICT(name) DO UPDATE SET type=excluded.type,cursor=excluded.cursor,started=excluded.started WHERE type!=excluded.type;`),`DELETE FROM function_subscriptions WHERE name NOT IN (${definitions.map(fn=>literal(fn.name)).join(',')||"''"});`,"INSERT INTO meta(key,value) VALUES('function-registry-deployed','1') ON CONFLICT(key) DO UPDATE SET value='1';"].join(' ');
 }

package/lib/scaffold.mjs

@@ -68,7 +68,7 @@ export function slugify(name) {
  * No `database_id` until one is known: Wrangler (4.45.0+) and the Deploy to Cloudflare flow create the database
  * the binding names and keep it linked.
  */
-export function wranglerConfig({ worker, name, d1, d1Id = null, r2 = null, layout = 'root', main = null, ai = false, routes = null, paidParts = false, partsRateLimit = null, triggers = null }) {
+export function wranglerConfig({ worker, name, d1, d1Id = null, r2 = null, layout = 'root', main = null, ai = false, routes = null, paidParts = false, partsRateLimit = null, triggers = null, eventFeeds = null }) {
   const at = layout === 'site' ? { schema: '../node_modules', main: 'src/runtime/worker.js', dist: './dist', migrations: 'migrations' }
     : { schema: 'node_modules', main: 'site/src/runtime/worker.js', dist: './site/dist', migrations: 'site/migrations' };
   const rooms = [{ name: 'TABLE', class_name: 'Table' }, { name: 'LOBBY', class_name: 'Lobby' }, { name: 'GATE', class_name: 'Gate' }, { name: 'CONCENTRATOR', class_name: 'Concentrator' }];
@@ -100,7 +100,7 @@ export function wranglerConfig({ worker, name, d1, d1Id = null, r2 = null, layou
     // Workers AI, only when a server's AI guides think with it (agents_brain workers-ai; deploy adds it, 0.17.0).
     // Never in Previews: they do not inherit it, so a Preview's guides answer from the game's script.
     ...(ai ? { ai: { binding: 'AI' } } : {}),
-    vars: { STUDIO_NAME: name },
+    vars: { STUDIO_NAME: name, ...(eventFeeds&&Object.keys(eventFeeds).length?{STUDIO_EVENT_FEEDS:JSON.stringify(eventFeeds)}:{}) },
     observability: { enabled: true },
     previews: { vars: { STUDIO_NAME: name, HOMIE_PREVIEW: '1' }, durable_objects: { bindings: rooms } },
   };

package/lib/template-history.json

@@ -3195,6 +3195,48 @@
      }
     }
    }
+  },
+  "0.50.1": {
+   "files": {
+    "CLAUDE.md": "ddf2b2a0376202f6",
+    "README.md": "684b3cca8001673c",
+    "HANDOFF.md": "29337e2ace95b2e7",
+    "games/README.md": "5ad32fe80c61f117",
+    "music/README.md": "a3dc042dadd39df8",
+    "videos/README.md": "16babc3437d5545b",
+    "posts/README.md": "37841aae476bd540",
+    "site/README.md": "1dbdf22c03a1e505",
+    "site/src/worker.mjs": "6cc5c6131eaf6fd0"
+   },
+   "sections": {
+    "AGENTS.md": {
+     "(intro)": "394cbbe934e80722",
+     "## Version-matched authoring guides": "f6261a0e5801b96b",
+     "## Layout": "f3a280b8c96cd068",
+     "## Apps: one screen, roles and parts": "c10aa0441ea89702",
+     "## Commands (all through the pinned CLI in node_modules)": "5222e08ca55e326e",
+     "## The site": "0cb8dd9a6f8a0096",
+     "## Making games": "bb715272fd1a615b",
+     "## The Game Codex and progress": "0738ef719cef3a4c",
+     "## Art direction and models": "a48fff7bf0a5f2fc",
+     "## Running live games (the back office)": "51ebf2ab756f6e4d",
+     "## Servers and AI seats": "1ccfd549d2369a60",
+     "## Selling things (the shop)": "9e020d69dd6a954e",
+     "## Continuing a build from the Claude app": "0d68081e924ca419",
+     "## Rules": "b2234d80f6cbe71d",
+     "## Telling Homie": "80b46fdd9e578db8",
+     "## Beta": "9d02638207a26e73"
+    }
+   },
+   "named": {
+    "Homie Arcade": {
+     "sections": {
+      "AGENTS.md": {
+       "## Commands (all through the pinned CLI in node_modules)": "611b437f5b3303f0"
+      }
+     }
+    }
+   }
   }
  }
 }

package/lib/worker-config.mjs

@@ -24,5 +24,5 @@ export function refreshWorkerConfig(root,overrides={}) {
   const tools=read(join(root,'site/src/tools/declarations.json'));
   const ai=cf.ai??listExperiences(root).some(g=>g.decide===true || g.chat!==false && (g.chat?.mode??'text')==='text' && g.chat?.ai!==false);
   const paid=paidReleases(root).length>0||existsSync(join(root,'shop.json'))||tools.paid===true;
-  updateWorkerConfig(root,wranglerConfig({worker:cf.worker,name:studio.name,d1:cf.d1,d1Id:cf.d1Id,r2:cf.r2,layout:layoutOf(root),ai,paidParts:paid,partsRateLimit:cf.purchaseRateLimit??null,routes:cf.routes??null,triggers:functions.length?{crons:[...new Set(['* * * * *',...functions.map(f=>f.schedule).filter(Boolean)])].sort()}:null,...overrides}));
+  updateWorkerConfig(root,wranglerConfig({worker:cf.worker,name:studio.name,d1:cf.d1,d1Id:cf.d1Id,r2:cf.r2,layout:layoutOf(root),ai,paidParts:paid,partsRateLimit:cf.purchaseRateLimit??null,routes:cf.routes??null,eventFeeds:studio.mcp?.events,triggers:functions.length||Object.keys(studio.mcp?.events??{}).length?{crons:[...new Set(['* * * * *',...functions.map(f=>f.schedule).filter(Boolean)])].sort()}:null,...overrides}));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homie-rocks/studio",
-  "version": "0.50.0",
+  "version": "0.50.1",
   "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/tools/TOOLS.md

@@ -151,3 +151,24 @@ page. App record collections retain their own role capabilities.
 MCP calls have no default rate limit. Set `mcp.callsPerMinute` only if the studio
 chooses a policy. Payment-provider requirements (such as a currency supported by
 the configured wallet or tax calculation in Checkout) still apply.
+
+## Booking notifications and staff access
+
+For “tell my AI when a booking comes in”, follow the worked example in
+`functions/FUNCTIONS.md`: declare `mcp.events.bookings` in `studio.json`, build,
+then connect the owner's AI to `/mcp` with OAuth. Subscribe to
+`studio://events/bookings` with `resources/subscribe` and keep the authenticated
+SSE GET open. `notifications/resources/updated` carries the event in
+`params._meta["studio/event"]`. Resume with the SSE `Last-Event-ID`; do not poll.
+Nothing is enabled by default. Outbound webhooks are not included in 0.50.1.
+
+The owner can call `app_role` with `{app, role, signIn, revoke}`. `signIn` is an
+existing account's verified email or exact account name, not an account ID.
+Ambiguous names require a verified email. Grant with `revoke: false`; revoke with
+`revoke: true`. The person must first have signed in. Current grants govern tools,
+resources and event delivery.
+
+`app_records` also accepts `operation: "delete"`, with the record's current
+`version`, where the selected role declares `delete:<collection>`. Record conflict
+messages are returned intact so the AI can reload and retry; unexpected tool
+errors remain generic to avoid exposing secrets.

package/tools/tools.ts

@@ -3,7 +3,7 @@ export type Audience = 'public' | 'signed-in' | 'owner' | { app: string; role: s
 export interface ToolContext {
   readonly purchase?: { readonly id: string };
   readonly caller: { readonly id: string | null; readonly owner: boolean; readonly client: string | null; readonly roles: Readonly<Record<string, readonly string[]>> };
-  records(args: { app: string; role?: string; collection: string; id?: string; operation?: 'read' | 'create' | 'update'; data?: Record<string, unknown>; version?: number }): Promise<unknown>;
+  records(args: { app: string; role?: string; collection: string; id?: string; operation?: 'read' | 'create' | 'update' | 'delete'; data?: Record<string, unknown>; version?: number }): Promise<unknown>;
   office(path: string, body?: Record<string, unknown>, query?: Record<string, string>): Promise<unknown>;
   shop(): Promise<unknown>;
   rooms: { send(event: {game: string; room: string; event: string; data: unknown}): Promise<unknown> };

package/worker/build-id.mjs

@@ -1,2 +1,2 @@
 // Generated by lib/build-identity.mjs; identifies the bundled runtime sources.
-export const STUDIO_BUILD = Object.freeze({"version":"0.50.0","sha256":"817f88f291b3f1dc92e51bb54784034debeabc202a269a2466a1efc2ef07d292"});
+export const STUDIO_BUILD = Object.freeze({"version":"0.50.1","sha256":"0ff5d7cf032cfcbfd6fa3a787c60055eadce37a46fd8f7fc09c33e073310d6ae"});

package/worker/event-resources.mjs

@@ -0,0 +1,116 @@
+import {allowed,currentCaller} from './mcp-tools.mjs';
+import {settingsOf,launchOf} from './office.mjs';
+
+/** Explicit studio declarations only; these also retain their event types. */
+export function eventFeeds(env) {
+  return JSON.parse(env.STUDIO_EVENT_FEEDS??'{}');
+}
+export function feedSubscriptions(env) {
+  return Object.entries(eventFeeds(env)).map(([name,feed])=>({name:'@events/'+name,event:feed.event}));
+}
+export const feedUri=name=>'studio://events/'+name;
+export async function readableFeed(env,cat,caller,name) {
+  const feed=eventFeeds(env)[name];
+  if(!feed||!caller.id||!await allowed(feed.audience??'owner',caller,env))return false;
+  if(feed.event==='record.changed') {
+    const app=cat.games.find(g=>g.id===feed.app&&g.kind==='app');
+    if(!app||!app.records?.collections?.[feed.collection])return false;
+    if(caller.owner)return true;
+    if(launchOf(app,await settingsOf(env,{fresh:true}),env)!=='public')return false;
+    return Object.entries(app.roles??{}).some(([role,decl])=>decl.can.includes('read:'+feed.collection)&&(!decl.signIn||caller.roles?.[app.id]?.includes(role)));
+  }
+  // Non-record events have no app read capability; they remain owner-only.
+  return caller.owner===true;
+}
+export async function feedEvents(env,name,{after=0,through=Number.MAX_SAFE_INTEGER}={}) {
+  const feed=eventFeeds(env)[name];if(!feed)return [];
+  const rows=(await env.DB.prepare('SELECT seq,id,type,data,at FROM studio_events WHERE type=?1 AND seq>?2 AND seq<=?3 ORDER BY seq LIMIT 100').bind(feed.event,after,through).all()).results;
+  return rows.map(r=>({...r,data:JSON.parse(r.data)}));
+}
+export function matchesFeed(feed,event) {
+  return feed.event===event.type && (feed.event!=='record.changed'||(event.data.app===feed.app&&event.data.collection===feed.collection));
+}
+const key=(connection,name)=>'event-sub:'+connection+':'+name;
+export async function subscribeFeed(env,cat,caller,uri,remove=false) {
+  const name=uri?.startsWith('studio://events/')?uri.slice(16):'';
+  if(!/^[a-z][a-z0-9-]*$/.test(name)||!await readableFeed(env,cat,caller,name))throw new Error('Event resource unavailable');
+  if(remove)await env.DB.prepare('DELETE FROM mcp_kv WHERE key=?1').bind(key(caller.connection,name)).run();
+  else {
+    const seq=(await env.DB.prepare('SELECT COALESCE(MAX(seq),0) seq FROM studio_events').first()).seq;
+    await env.DB.prepare('INSERT OR IGNORE INTO mcp_kv(key,value,expires) VALUES(?1,?2,NULL)').bind(key(caller.connection,name),JSON.stringify({connection:caller.connection,name,after:seq})).run();
+  }
+}
+export function eventHub(env,connection) {return env.LOBBY.get(env.LOBBY.idFromName('@studio-events/'+connection));}
+export async function pushEvents(env,cat,origin) {
+  if(!env.LOBBY||!Object.keys(eventFeeds(env)).length)return;
+  // Page subscriptions, without a studio-wide subscription or delivery cap.
+  let after='';const seen=new Set();
+  for(;;){
+    const rows=(await env.DB.prepare("SELECT key,value FROM mcp_kv WHERE key LIKE 'event-sub:%' AND key>?1 ORDER BY key LIMIT 100").bind(after).all()).results;
+    for(const row of rows){const {connection}=JSON.parse(row.value);if(seen.has(connection))continue;seen.add(connection);
+      const response=await eventHub(env,connection).fetch('https://events/__studio_events',{method:'POST',body:JSON.stringify({op:'wake',connection,cat,origin})});
+      if(!response.ok)throw new Error('Event stream wake failed');
+    }
+    if(rows.length<100)break;after=rows.at(-1).key;
+  }
+}
+
+/** One existing Lobby object per OAuth connection: streams never live in a Worker isolate. */
+export class EventStreams {
+  constructor(env,ctx){this.env=env;this.ctx=ctx;this.stream=null;this.tail=Promise.resolve();}
+  close(stream){stream.cancelled=true;stream.resume?.();try{stream.controller.close();}catch{}if(this.stream===stream)this.stream=null;}
+  background(input){this.ctx.waitUntil(this.wake(input).catch(error=>{if(this.stream)this.close(this.stream);console.error('Event stream delivery failed',error);}));}
+  async fetch(request) {
+    const input=await request.json();
+    if(input.op==='stream') {
+      // A reconnect replaces the previous GET, including a half-open socket.
+      if(this.stream)this.close(this.stream);
+      await this.tail;
+      const {connection,lastId}=input;
+      const subscriptions=(await this.env.DB.prepare("SELECT value FROM mcp_kv WHERE key LIKE ?1").bind('event-sub:'+connection+':%').all()).results;
+      let after=subscriptions.length?Math.min(...subscriptions.map(r=>JSON.parse(r.value).after)):(await this.env.DB.prepare('SELECT COALESCE(MAX(seq),0) seq FROM studio_events').first()).seq,name='';
+      if(lastId){const parts=lastId.split('/');if(parts.length!==3||parts[0]!==connection||!/^\d+$/.test(parts[1]))return new Response('Invalid Last-Event-ID',{status:400});after=Number(parts[1]);name=parts[2];}
+      const stream={...input,after,name,controller:null,cancelled:false,resume:null};
+      const body=new ReadableStream({start:controller=>{stream.controller=controller;controller.enqueue(new TextEncoder().encode(': connected\n\n'));},pull:()=>{const resume=stream.resume;stream.resume=null;resume?.();},cancel:()=>this.close(stream)});
+      this.stream=stream;
+      // Replay and later wakes share one ordered pump. Backpressure must not
+      // hold up the writer's request or a function handler.
+      this.background(input);
+      return new Response(body,{headers:{'content-type':'text/event-stream','cache-control':'no-store'}});
+    }
+    this.background(input);return new Response(null,{status:204});
+  }
+  wake(input){const work=this.tail.then(()=>this.deliver(input));this.tail=work.catch(()=>{});return work;}
+  async deliver(input) {
+    const stream=this.stream;if(!stream)return;
+    let caller;
+    try{caller=await currentCaller(this.env,{connection:input.connection});}
+    catch{this.close(stream);return;}
+    const rows=(await this.env.DB.prepare("SELECT value FROM mcp_kv WHERE key LIKE ?1").bind('event-sub:'+caller.connection+':%').all()).results;
+    const subscriptions=[];
+    for(const row of rows){const sub=JSON.parse(row.value);if(await readableFeed(this.env,input.cat,caller,sub.name))subscriptions.push(sub);}
+    const through=(await this.env.DB.prepare('SELECT COALESCE(MAX(seq),0) seq FROM studio_events').first()).seq;
+    let cursor=Math.max(0,stream.after-1);
+    for(;;){
+      const events=(await this.env.DB.prepare('SELECT seq,id,type,data,at FROM studio_events WHERE seq>?1 AND seq<=?2 ORDER BY seq LIMIT 100').bind(cursor,through).all()).results;
+      for(const raw of events){const event={...raw,data:JSON.parse(raw.data)};
+        for(const sub of subscriptions.sort((a,b)=>a.name<b.name?-1:a.name>b.name?1:0)){
+          if(event.seq<=sub.after||event.seq<stream.after||event.seq===stream.after&&sub.name<=stream.name||!matchesFeed(eventFeeds(this.env)[sub.name],event))continue;
+          if(stream.cancelled)return;
+          if(stream.controller.desiredSize<=0)await new Promise(resolve=>{stream.resume=resolve;});
+          if(stream.cancelled)return;
+          // Recheck identity and grants for every event, including replay.
+          const fresh=await currentCaller(this.env,{connection:caller.connection}).catch(()=>null);
+          if(!fresh){this.close(stream);return;}
+          if(!await readableFeed(this.env,input.cat,fresh,sub.name))continue;
+          if(!await this.env.DB.prepare('SELECT key FROM mcp_kv WHERE key=?1').bind(key(caller.connection,sub.name)).first())continue;
+          const id=`${caller.connection}/${event.seq}/${sub.name}`;
+          const notification={jsonrpc:'2.0',method:'notifications/resources/updated',params:{uri:feedUri(sub.name),_meta:{'studio/event':event}}};
+          try{stream.controller.enqueue(new TextEncoder().encode(`id: ${id}\nevent: message\ndata: ${JSON.stringify(notification)}\n\n`));}catch{this.close(stream);return;}
+          stream.after=event.seq;stream.name=sub.name;
+        }
+      }
+      if(events.length<100)break;cursor=events.at(-1).seq;
+    }
+  }
+}

package/worker/functions.mjs

@@ -1,11 +1,13 @@
+import {feedSubscriptions,pushEvents} from './event-resources.mjs';
 import { services } from './mcp-tools.mjs';
 import { isOwner, sameOrigin } from './office.mjs';
 import { esc } from './site.mjs';
 let load = async () => [];
 export function useFunctions(loader) { load = loader; }
-export async function hasFunctionType(type) { return (await load()).some(fn=>fn.event===type); }
+export async function hasFunctionType(type,env={}) { return [...await load(),...feedSubscriptions(env)].some(fn=>fn.event===type); }
 export async function syncFunctions(env, definitions = null, now = Date.now()) {
   definitions ??= await load();
+  definitions=[...definitions.filter(fn=>!fn.name.startsWith('@events/')),...feedSubscriptions(env)];
   if (!env.DB || !definitions.length) return definitions;
   // Deploy owns the production registry; an old in-flight Worker must not overwrite it.
   if(await env.DB.prepare("SELECT 1 FROM meta WHERE key='function-registry-deployed'").first())return definitions;
@@ -39,29 +41,41 @@ export async function runFunctions(env, cat, origin, {definitions, now = Date.no
   definitions = await syncFunctions(env,definitions,now());
   if(!definitions.length)return;
   if(typeof cat==='function')cat=await cat();
-  for (const fn of definitions) {
-    const subscription=await env.DB.prepare('SELECT cursor,type FROM function_subscriptions WHERE name=?1').bind(fn.name).first();
-    if(!subscription || subscription.type!==fn.event)continue;
-    const page=(await env.DB.prepare('SELECT seq,id,data FROM studio_events WHERE type=?1 AND seq>?2 ORDER BY seq LIMIT 100').bind(fn.event,subscription.cursor).all()).results;
-    if(page.length)await env.DB.batch([
-      ...page.filter(e=>!fn.schedule||JSON.parse(e.data).function===fn.name).map(e=>env.DB.prepare('INSERT OR IGNORE INTO function_deliveries(event,function) SELECT id,?2 FROM studio_events WHERE id=?1').bind(e.id,fn.name)),
-      env.DB.prepare('UPDATE function_subscriptions SET cursor=MAX(cursor,?2) WHERE name=?1').bind(fn.name,page.at(-1).seq),
-    ]);
-    const rows=(await env.DB.prepare(`SELECT d.*,e.type,e.data,e.at FROM function_deliveries d JOIN studio_events e ON e.id=d.event WHERE d.function=?1 AND d.state IN ('pending','failed','running') AND d.due<=?2 ORDER BY d.due LIMIT 100`).bind(fn.name,now()).all()).results;
-    for (const row of rows) {
-      const lease=crypto.randomUUID();
-      const claimed=await env.DB.prepare(`UPDATE function_deliveries SET state='running',lease=?3,due=?4,attempts=attempts+1 WHERE event=?1 AND function=?2 AND state!='complete' AND due<=?5`).bind(row.event,fn.name,lease,now()+leaseMs,now()).run();
-      if (!claimed.meta.changes) continue;
-      try {
-        const event=Object.freeze({id:row.event,type:row.type,at:row.at,data:JSON.parse(row.data),attempt:row.attempts+1});
-        await fn.handler(event,services(env,cat,origin,{id:'studio-function',owner:true,client:null},'function:'+fn.name,fn));
-        await env.DB.prepare(`UPDATE function_deliveries SET state='complete',completed=?4,error=NULL WHERE event=?1 AND function=?2 AND lease=?3`).bind(row.event,fn.name,lease,now()).run();
-      } catch {
-        // Handler errors may contain credentials. The office identifies the function/event; Worker logs are the studio's debugging surface.
-        await env.DB.prepare(`UPDATE function_deliveries SET state='failed',error='Function failed; inspect its code and retry',due=?4 WHERE event=?1 AND function=?2 AND lease=?3`).bind(row.event,fn.name,lease,now()+leaseMs).run();
+  // An AI notification must not wait behind a slow function handler.
+  const notify=()=>pushEvents(env,cat,origin).catch(error=>console.error('Event notification wake failed',error));
+  const notifications=notify();
+  let more;
+  do {
+    more=false;
+    for (const fn of definitions) {
+      if(!fn.handler)continue;
+      const subscription=await env.DB.prepare('SELECT cursor,type FROM function_subscriptions WHERE name=?1').bind(fn.name).first();
+      if(!subscription || subscription.type!==fn.event)continue;
+      const page=(await env.DB.prepare('SELECT seq,id,data FROM studio_events WHERE type=?1 AND seq>?2 ORDER BY seq LIMIT 100').bind(fn.event,subscription.cursor).all()).results;
+      if(page.length)more=true;
+      if(page.length)await env.DB.batch([
+        ...page.filter(e=>!fn.schedule||JSON.parse(e.data).function===fn.name).map(e=>env.DB.prepare('INSERT OR IGNORE INTO function_deliveries(event,function) SELECT id,?2 FROM studio_events WHERE id=?1').bind(e.id,fn.name)),
+        env.DB.prepare('UPDATE function_subscriptions SET cursor=MAX(cursor,?2) WHERE name=?1').bind(fn.name,page.at(-1).seq),
+      ]);
+      const rows=(await env.DB.prepare(`SELECT d.*,e.type,e.data,e.at FROM function_deliveries d JOIN studio_events e ON e.id=d.event WHERE d.function=?1 AND d.state IN ('pending','failed','running') AND d.due<=?2 ORDER BY d.due LIMIT 100`).bind(fn.name,now()).all()).results;
+      if(rows.length===100)more=true;
+      for (const row of rows) {
+        const lease=crypto.randomUUID();
+        const claimed=await env.DB.prepare(`UPDATE function_deliveries SET state='running',lease=?3,due=?4,attempts=attempts+1 WHERE event=?1 AND function=?2 AND state!='complete' AND due<=?5`).bind(row.event,fn.name,lease,now()+leaseMs,now()).run();
+        if (!claimed.meta.changes) continue;
+        try {
+          const event=Object.freeze({id:row.event,type:row.type,at:row.at,data:JSON.parse(row.data),attempt:row.attempts+1});
+          await fn.handler(event,services(env,cat,origin,{id:'studio-function',owner:true,client:null},'function:'+fn.name,fn));
+          await env.DB.prepare(`UPDATE function_deliveries SET state='complete',completed=?4,error=NULL WHERE event=?1 AND function=?2 AND lease=?3`).bind(row.event,fn.name,lease,now()).run();
+        } catch {
+          // Handler errors may contain credentials. The office identifies the function/event; Worker logs are the studio's debugging surface.
+          await env.DB.prepare(`UPDATE function_deliveries SET state='failed',error='Function failed; inspect its code and retry',due=?4 WHERE event=?1 AND function=?2 AND lease=?3`).bind(row.event,fn.name,lease,now()+leaseMs).run();
+        }
       }
     }
-  }
+  } while(more);
+  await notifications;
+  await notify();
   await pruneEvents(env);
 }
 export async function scheduleFunctions(event,env,cat,origin) {

package/worker/index.mjs

@@ -621,18 +621,31 @@ export default {
   async fetch(request, env, ctx) {
     const url = new URL(request.url);
     await (await import('./functions.mjs')).syncFunctions(env);
+    const dispatch=()=>import('./functions.mjs').then(m=>m.runFunctions(env,()=>catalogue(env,url.origin),url.origin));
+    // Some routes reconcile shop state in waitUntil after returning their page.
+    // Keep dispatch behind those writes too, preserving the runtime context's
+    // methods and OAuth verification symbols through the proxy.
+    const requestCtx=ctx?.waitUntil?new Proxy(ctx,{get(target,key){
+      if(key==='waitUntil')return work=>ctx.waitUntil(Promise.resolve(work).finally(dispatch));
+      const value=Reflect.get(target,key,target);return typeof value==='function'?value.bind(target):value;
+    }}):ctx;
     // A standalone copy's Lobby call (worker/standalone.mjs): every answer to it can be read by the app's page, an
     // unknown game's 404 and a failure included, so the app can say why it plays offline. No other address is opened.
     const appRecords = isAppOrigin(request) && /^\/[^/]+\/api\/app\/records\//.test(url.pathname);
     if (appRecords && request.method === 'OPTIONS') return appCors(request, new Response(null, { status: 204, headers: { 'access-control-allow-methods': 'GET, POST, PUT, DELETE', 'access-control-allow-headers': 'content-type' } }));
     const appLobby = isAppOrigin(request) && /^\/[^/]+\/api\/lobby\/?$/.test(url.pathname);
     let res;
-    try { res = finish(await route(request, env, ctx), url.pathname); } catch (error) {
+    try { res = finish(await route(request, env, requestCtx), url.pathname); } catch (error) {
       if (!appLobby) throw error;
       try { console.error(JSON.stringify({ at: new Date().toISOString(), ev: 'lobby-route-failed', path: url.pathname, error: errorLine(error) })); } catch { /* no console */ }
       res = json({ ok: false, error: 'failed' }, 500);
+    } finally {
+      // A route can commit a write and then fail. Its outbox still needs delivery.
+      if(env.DB) {
+        const delivery=dispatch();
+        if(ctx?.waitUntil)ctx.waitUntil(delivery);else await delivery;
+      }
     }
-    if(ctx?.waitUntil && ['POST','PUT','DELETE'].includes(request.method)) ctx.waitUntil((async()=>{const {runFunctions}=await import('./functions.mjs');await runFunctions(env,()=>catalogue(env,url.origin),url.origin);})());
     if (appLobby || appRecords) return appCors(request, res);
     // A referral's arrival (worker/referrals.mjs): only a person's page load with ?via= of another site, on a studio
     // that pays referrals. The page is answered first; a cookie is added to it only then.
@@ -1840,7 +1853,7 @@ export class Table {
   queueFunctionEvent(type,data) {
     if(!this.env.DB || this.env.HOMIE_PREVIEW==='1' || !this.ctx.storage.sql) return;
     this.ctx.waitUntil((async()=>{
-      if(!await (await import('./functions.mjs')).hasFunctionType(type))return;
+      if(!await (await import('./functions.mjs')).hasFunctionType(type,this.env))return;
       const sql=this.ctx.storage.sql;
       sql.exec('CREATE TABLE IF NOT EXISTS function_outbox(id TEXT PRIMARY KEY,type TEXT,data TEXT,at INTEGER)');
       sql.exec('INSERT INTO function_outbox VALUES(?,?,?,?)',crypto.randomUUID(),type,JSON.stringify(data),Date.now());
@@ -1858,6 +1871,8 @@ export class Table {
       try {await emitEvent(this.env,row.type,JSON.parse(row.data),{id:row.id,at:row.at});sql.exec('DELETE FROM function_outbox WHERE id=?',row.id);}
       catch {this.armRoom(Date.now()+60000);await this.alarmWrite;return;}
     }
+    const cat=await catalogue(this.env,'https://studio.invalid');
+    await (await import('./functions.mjs')).runFunctions(this.env,cat,cat.studio?.url??'https://studio.invalid');
   }
 
   /**
@@ -2565,6 +2580,11 @@ export class Lobby {
 
   /** A request that throws is said with what it was (never its body) and answered as a failure, not left uncaught. */
   async fetch(request) {
+    if(new URL(request.url).pathname==='/__studio_events') {
+      const {EventStreams}=await import('./event-resources.mjs');
+      this.eventStreams??=new EventStreams(this.env,this.ctx);
+      return this.eventStreams.fetch(request);
+    }
     try { return await this.answer(request); } catch (error) {
       let path = '';
       try { path = new URL(request.url).pathname; } catch { /* not an address */ }

package/worker/mcp-tools.mjs

@@ -38,10 +38,10 @@ export function services(env, cat, origin, caller, namespace, definition = {}) {
     if (!meta || !/^[a-z][a-z0-9-]{0,39}$/.test(collection) || (id!==undefined && !/^[A-Za-z0-9_-]{1,64}$/.test(id))) throw new Error('unknown app, collection or record');
     if (!caller.owner && launchOf(meta,await settingsOf(env,{fresh:true}),env)!=='public') throw new Error('app is private');
     const url = new URL(`/${app}/api/app/records/${collection}${id ? '/'+id : ''}`,origin);if(role)url.searchParams.set('role',role);
-    const method = {read:'GET',create:'POST',update:'PUT'}[operation];if (!method) throw new Error('unsupported operation');
+    const method = {read:'GET',create:'POST',update:'PUT',delete:'DELETE'}[operation];if (!method) throw new Error('unsupported operation');
     const request = withToolIdentity(new Request(url,{method,headers:{origin,'content-type':'application/json'},...(method==='GET'?{}:{body:JSON.stringify({data,version})})}),caller);
     const response = await appRecordsRoute(request,env,meta,url,url.pathname.slice(app.length+2));
-    const result = await response.json(); if(!response.ok) throw new Error(result.error);return result;
+    const result = await response.json(); if(!response.ok) {const error=new Error(result.error);error.name='StudioOperationError';throw error;}return result;
   };
   const office = async (path, body, query={}) => {
     const delegated=definition.delegateOffice && await allowed(definition.audience,caller,env);
@@ -91,6 +91,17 @@ export function builtins(env,cat,origin) {
     tool('studio_info','The public studio, apps, games and posts.','public',object(),async()=>{const pub=publicCatalogue(cat,await settingsOf(env),env);return {studio:pub.studio?.name,games:pub.games.map(g=>({id:g.id,name:g.name,kind:g.kind??'game'})),posts:pub.posts};}),
     tool('studio_office','Live rooms and the players as shown in the office.','owner',object(),(_,ctx)=>ctx.office('/_studio/api/office')),
     tool('studio_shop','Orders, refunds and the shop state.','owner',object(),(_,ctx)=>ctx.shop()),
+    tool('app_role','Grant or revoke a staff role by verified email or exact sign-in name.','owner',object({app:str,role:str,signIn:{type:'string',maxLength:254},revoke:{type:'boolean'}},['app','role','signIn']),async({app,role,signIn,revoke},ctx)=>{
+      if(!ctx.caller.owner)throw new Error('Owner only');
+      const meta=cat.games.find(g=>g.id===app&&g.kind==='app');
+      if(!meta?.roles?.[role]?.signIn)throw new Error('Name a sign-in role');
+      const people=signIn.includes('@')
+        ? (await env.DB.prepare('SELECT p.id FROM players p JOIN player_emails e ON e.player=p.id WHERE e.email=?1 AND e.verified_at IS NOT NULL AND p.guest=0').bind(signIn.trim().toLowerCase()).all()).results
+        : (await env.DB.prepare('SELECT id FROM players WHERE name=?1 AND guest=0').bind(signIn).all()).results;
+      if(people.length!==1){const error=new Error(people.length?'Sign-in is ambiguous; use a verified email':'No signed-in account matches; ask the person to sign in first');error.name='StudioOperationError';throw error;}
+      await env.DB.prepare(revoke?'DELETE FROM app_roles WHERE app=?1 AND role=?2 AND player=?3':'INSERT OR IGNORE INTO app_roles(app,role,player) VALUES(?1,?2,?3)').bind(app,role,people[0].id).run();
+      return {ok:true,app,role,revoked:revoke===true};
+    }),
     tool('studio_players','The studio accounts as shown in the office.','owner',object({query:str}),({query})=>players.list(env,{q:query})),
     tool('studio_stats','Studio visits and plays.','owner',object(),()=>readStats(env,cat,{range:rangeOf(new URLSearchParams())})),
     tool('studio_posts','Published posts.','public',object(),()=>({posts:cat.posts??[]})),
@@ -102,7 +113,7 @@ export function builtins(env,cat,origin) {
       const collections=new Set(Object.values(roles).flatMap(r=>r.can.map(cap=>cap.split(':')[1])));
       return {app,roles,collections:Object.fromEntries(Object.entries(meta.records?.collections??{}).filter(([name])=>collections.has(name)))};
     }),
-    tool('app_records','List, read, create or update app records with the app role and record version.','public',object({app:str,role:str,collection:str,id:str,operation:{enum:['read','create','update']},data:{type:'object'},version:{type:'integer',minimum:1}},['app','collection']), (args,ctx)=>ctx.records(args)),
+    tool('app_records','List, read, create, update or delete app records with the app role and record version.','public',object({app:str,role:str,collection:str,id:str,operation:{enum:['read','create','update','delete']},data:{type:'object'},version:{type:'integer',minimum:1}},['app','collection']), (args,ctx)=>ctx.records(args)),
   ];
   for(const [name,path,description] of [
     ['room_announce','announce','Announce to a room.'],['room_kick','kick','Ask the owner to remove a player.'],['room_mute','mute','Ask the owner to mute a player.'],['room_close','close','Ask the owner to close a room.'],['studio_game','game','Ask the owner to change game access or room size.'],['shop_refund','shop/refund','Ask the owner to refund an order.'],

package/worker/mcp.mjs

@@ -1,7 +1,8 @@
+import {eventFeeds,feedUri,readableFeed,feedEvents,matchesFeed,subscribeFeed,eventHub} from './event-resources.mjs';
 import { selling } from './extensions.mjs';
 import OAuthProvider from '@cloudflare/workers-oauth-provider';
 import { createMcpHandler } from 'agents/mcp/server';
-import { McpServer, fromJsonSchema, ProtocolError } from '@modelcontextprotocol/server';
+import { McpServer, ResourceTemplate, fromJsonSchema, ProtocolError } from '@modelcontextprotocol/server';
 import { CfWorkerJsonSchemaValidator } from '@modelcontextprotocol/server/validators/cf-worker';
 import { players } from './players.mjs';
 import { isOwner, sameOrigin } from './office.mjs';
@@ -14,12 +15,12 @@ const json = (data,status=200)=>Response.json(data,{status,headers:{'cache-contr
 const html = (body,headers={})=>new Response(`<!doctype html><html lang="en"><meta charset="utf-8"><meta name="viewport" content="width=device-width"><title>Connect your AI</title><style>body{font:18px system-ui;max-width:640px;margin:64px auto;padding:24px;background:#faf9f6;color:#252520}button,a{padding:12px}button{font:inherit}li{margin:16px 0}</style><main>${body}</main></html>`,{headers:{'content-type':'text/html; charset=utf-8','cache-control':'no-store','content-security-policy':"default-src 'none'; style-src 'unsafe-inline'; form-action 'self'; frame-ancestors 'none'; base-uri 'none'",...Object.fromEntries(new Headers(headers))}});
 async function browserPerson(request,env) {
   const person=await players.of(request,env);
-  if(person&&!person.guest)return person.id;
+  if(person&&!person.guest&&person.owner)return person.id;
   if(await isOwner(request,env)) {
     const token=cookieValue(request,'studio_owner');
     if(token){const hash=await crypto.subtle.digest('SHA-256',new TextEncoder().encode(token));return 'office-'+[...new Uint8Array(hash)].map(b=>b.toString(16).padStart(2,'0')).join('');}
   }
-  return null;
+  return person&&!person.guest?person.id:null;
 }
 const paymentInputSchema={type:'object',properties:{buyer:{type:'string',pattern:'^[a-f0-9]{64}$'},claim:{type:'string',pattern:'^[a-f0-9]{64}$'},offerVersion:{type:'string'},checkout:{type:'boolean'}},additionalProperties:false};
 export async function remoteMcp(request,env,ctx,{catalogueOf,definitions=[]}) {
@@ -31,7 +32,12 @@ export async function remoteMcp(request,env,ctx,{catalogueOf,definitions=[]}) {
   const api=async(request,env,ctx)=>{
     let caller;
     try{caller=await currentCaller(env,ctx.props);}catch{return new Response(JSON.stringify({error:'connection revoked'}),{status:401,headers:{'content-type':'application/json','cache-control':'no-store','www-authenticate':`Bearer resource_metadata="${origin}/.well-known/oauth-protected-resource/mcp", error="invalid_token"`}});}
-    const cat=await catalogueOf();const tools=[...builtins(env,cat,origin),...definitions];
+    const cat=await catalogueOf();
+    if(request.method==='GET'&&Object.keys(eventFeeds(env)).length&&caller.connection) {
+      if(!request.headers.get('accept')?.includes('text/event-stream'))return json({error:'Accept text/event-stream required'},406);
+      return eventHub(env,caller.connection).fetch('https://events/__studio_events',{method:'POST',body:JSON.stringify({op:'stream',connection:caller.connection,lastId:request.headers.get('last-event-id'),cat,origin})});
+    }
+    const tools=[...builtins(env,cat,origin),...definitions];
     if(request.method==='POST') {
       const body=await request.clone().json().catch(()=>null);
       if(body?.method==='tools/call') {
@@ -48,12 +54,35 @@ export async function remoteMcp(request,env,ctx,{catalogueOf,definitions=[]}) {
     const read=async(name,handler)=>{
       let outcome='error';
       try{const fresh=await currentCaller(env,ctx.props);await rate(fresh);const result=await handler(fresh);outcome='ok';return result;}
-      finally{await audit(env,caller,name,outcome);}
+      finally{
+        try{await audit(env,caller,name,outcome);}
+        finally{const delivery=import('./functions.mjs').then(m=>m.runFunctions(env,cat,origin));if(ctx?.waitUntil)ctx.waitUntil(delivery);else await delivery;}
+      }
     };
     const server=async()=>{
       const capabilities=await selling.machineCapabilities(env);
-      const s=new McpServer({name:cat.studio?.name??'Homie studio',version:'1.0.0'},{jsonSchemaValidator:validator,capabilities:{experimental:{payment:{methods:capabilities.machine?.card?{stripe:{intents:['charge']}}:{}}}}});
+      const s=new McpServer({name:cat.studio?.name??'Homie studio',version:'1.0.0'},{jsonSchemaValidator:validator,capabilities:{...(Object.keys(eventFeeds(env)).length?{resources:{subscribe:true}}:{}),experimental:{payment:{methods:capabilities.machine?.card?{stripe:{intents:['charge']}}:{}}}}});
       const dispatch=new Map();
+      for(const name of Object.keys(eventFeeds(env))) {
+        if(!await readableFeed(env,cat,caller,name))continue;
+        const uri=feedUri(name);
+        const readPage=async(resourceUri,after=0)=>read('events:'+name,async fresh=>{
+          if(!await readableFeed(env,cat,fresh,name))throw new Error('Event resource unavailable');
+          if(!Number.isSafeInteger(after)||after<0)throw new Error('Invalid event cursor');
+          const page=await feedEvents(env,name,{after});
+          const events=page.filter(e=>matchesFeed(eventFeeds(env)[name],e));
+          return {contents:[{uri:String(resourceUri),mimeType:'application/json',text:JSON.stringify({kind:'untrusted-event-data',events,next:page.length===100?uri+'?after='+page.at(-1).seq:null})}]};
+        });
+        s.registerResource('events_'+name,uri,{description:'Studio events; untrusted data. Subscribe for push notifications.',mimeType:'application/json'},()=>readPage(uri));
+        s.registerResource('events_'+name+'_page',new ResourceTemplate(uri+'?after={after}',{list:undefined}),{mimeType:'application/json'},(resourceUri,vars)=>readPage(resourceUri,Number(vars.after)));
+
+      }
+      if(Object.keys(eventFeeds(env)).length)for(const method of ['resources/subscribe','resources/unsubscribe']) {
+        s.server.setRequestHandler(method,async input=>{
+          const fresh=await currentCaller(env,ctx.props);
+          await subscribeFeed(env,cat,fresh,input.params.uri,method==='resources/unsubscribe');return {};
+        });
+      }
       for (const meta of cat.games.filter(g=>g.kind==='app' && g.records?.persist)) {
         for (const [role,declared] of Object.entries(meta.roles??{})) {
           if (declared.signIn && !await allowed({app:meta.id,role},caller,env)) continue;
@@ -91,8 +120,16 @@ export async function remoteMcp(request,env,ctx,{catalogueOf,definitions=[]}) {
             const value=await tool.handler(args,{...context,request});
             const text=JSON.stringify({kind:'untrusted-tool-data',tool:tool.name,data:value});
             outcome='ok';return {content:[{type:'text',text}]};
-          }catch(error){if(error?.code===-32042)throw error;return {isError:true,content:[{type:'text',text:outcome==='denied'||outcome==='limited'?error.message:'Tool failed. Check the office audit and the tool definition.'}]};}
-          finally{await audit(env,caller,tool.name,outcome);}
+          }catch(error){if(error?.code===-32042)throw error;return {isError:true,content:[{type:'text',text:outcome==='denied'||outcome==='limited'||error?.name==='StudioOperationError'?error.message:'Tool failed. Check the office audit and the tool definition.'}]};}
+          finally{
+            try { await audit(env,caller,tool.name,outcome); }
+            finally {
+              // Streamable HTTP returns headers before dispatch finishes. Wake only
+              // after the tool's writes (including audit triggers) have committed.
+              const delivery=import('./functions.mjs').then(m=>m.runFunctions(env,cat,origin));
+              if(ctx?.waitUntil)ctx.waitUntil(delivery);else await delivery;
+            }
+          }
         };
         s.registerTool(tool.name,{description:tool.description,inputSchema:fromJsonSchema(schema,validator)},handler);
         dispatch.set(tool.name,{schema,handler});

package/worker/version.mjs

@@ -1,2 +1,2 @@
 /** The @homie-rocks/studio version this Worker code is (package.json's; a test keeps them equal). Cache-busts /_homie/site.js. */
-export const STUDIO_VERSION_TAG = '0.50.0';
+export const STUDIO_VERSION_TAG = '0.50.1';