@homie-rocks/studio 0.24.2 → 0.24.4

package/netplay/netplay.ts

@@ -402,6 +402,8 @@ export interface NetStats {
   reconnects: number;
   promotions: number;
   round: number | null;
+  /** Section 20: the host's decisions: asked, answered by the studio's model ('ai'), the person's own Ollama ('local'), or the floor; median ms. */
+  decides?: { asked: number; ai: number; local: number; floor: number; msP50: number | null };
 }
 
 export interface Vec { x: number; y: number; z?: number }
@@ -497,6 +499,29 @@ export interface NetHandlers<S, A, C> {
   held: (h: ChatHeld) => void;
 }
 
+/**
+ * A GAME'S OWN DECISIONS (section 20): typed questions about the game's state that the studio's decision model (Clef)
+ * answers with a probability for every option, never with text. A Choice picks one option id (2 to 26), a yes/no
+ * (`noul`) is true or false, a Score is a level (2 to 10, lowest first; the answer is the probability-weighted level).
+ */
+export type DecideQuestion =
+  | { type: 'choice'; instructions: string; criteria: Record<string, string | null> }
+  | { type: 'noul'; instructions: string; criteria?: { true?: string; false?: string } }
+  | { type: 'score'; instructions: string; criteria: string[] };
+export type DecidePicks = Record<string, string | boolean | number>;
+/**
+ * What `decide` resolves to, always: `by` 'ai' (the studio's Workers AI) or 'local' (the person's own Ollama under dev),
+ * or 'floor' (the game's own answer: no AI, not opted in, over budget, paced, slow, not the host); `why` says which.
+ * `p`: the model's probability for each option (a choice), `{ yes }` (a yes/no), or each level (a score).
+ */
+export interface Decided { by: 'ai' | 'local' | 'floor'; picks: DecidePicks; p?: Record<string, Record<string, number>>; ms: number; why?: string }
+export interface DecideOptions {
+  /** The game's own answer, synchronous: used whenever the model's is not there in time. Missing picks fall back to it one by one. */
+  floor?: (state: unknown) => DecidePicks;
+  /** How long to wait for the model (default 2500 ms; at most 5000). */
+  ms?: number;
+}
+
 export interface Netplay<S = unknown, A = unknown, C = unknown> {
   readonly role: Role;
   readonly isHost: boolean;
@@ -640,6 +665,13 @@ export interface Netplay<S = unknown, A = unknown, C = unknown> {
   /** Interpolation pair for rendering remote entities. */
   sample(delayMs?: number): Sample<S> | null;
   latest(): Snapshot<S> | null;
+  /**
+   * Host: ask the studio's decision model (Clef) a few typed questions about the game's state, for a game whose
+   * game.json says "decide": true. Always resolves: with the model's picks, or the floor's when it cannot answer in
+   * time (no AI, over the day's budget, at most one ask every 3 s a room, a replica, offline). Never per frame: per
+   * beat (every few seconds), and the game keeps playing while it waits.
+   */
+  decide(state: unknown, questions: Record<string, DecideQuestion>, opts?: DecideOptions): Promise<Decided>;
   stats(): NetStats;
   expose(probes: Probes): void;
   close(): void;
@@ -1069,6 +1101,12 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
   /** Wall times of the input frames sent in the last second, and until when the slow cap holds. */
   const inSent: number[] = [];
   let inSlowUntil = 0;
+  /** Section 20: decisions waiting for the room's answer (by request id), and how long the room said it is off. */
+  const deciding = new Map<string, { done: (d: Decided) => void; timer: ReturnType<typeof setTimeout>; at: number; floor: () => Decided }>();
+  let decideSeq = 0;
+  let decideOffUntil = 0;
+  let decideNextAt = 0;
+  const decideStats = { asked: 0, ai: 0, local: 0, floor: 0, ms: [] as number[] };
   let idleSkipped = 0;
   /** Why this client stopped for good (a FINAL_ERRORS refusal), or null while it plays or reconnects. */
   let closedWhy: string | null = null;
@@ -1460,6 +1498,29 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
         resolveView('policy');
         return;
       }
+      case 'decided': {
+        const n = String(m['n'] ?? '');
+        const w = deciding.get(n);
+        if (!w) return;
+        deciding.delete(n);
+        clearTimeout(w.timer);
+        const ms = Math.round(wall() - w.at);
+        if (m['ok'] === true && m['picks'] && typeof m['picks'] === 'object') {
+          const base = w.floor();
+          const by = m['by'] === 'local' ? 'local' : 'ai';
+          decideStats[by] += 1;
+          decideStats.ms.push(ms); if (decideStats.ms.length > 40) decideStats.ms.shift();
+          w.done({ by, picks: { ...base.picks, ...(m['picks'] as DecidePicks) }, p: (m['p'] as Decided['p']) ?? {}, ms });
+          return;
+        }
+        const why = String(m['why'] ?? 'error');
+        // Not opted in, no AI or out of budget: ask again only after a minute. Paced: at the room's next slot.
+        if (why === 'off' || why === 'no-ai' || why === 'budget') decideOffUntil = wall() + 60_000;
+        if (why === 'pace' && Number.isFinite(Number(m['retryMs']))) decideNextAt = wall() + Number(m['retryMs']);
+        decideStats.floor += 1;
+        w.done({ ...w.floor(), why, ms });
+        return;
+      }
       case 'error': {
         const code = String(m['code'] ?? '');
         // Inputs over the relay's cap were dropped: send fewer for a while (the newest frame still goes out).
@@ -1748,6 +1809,7 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
       interpDelay: Math.round(interpDelay()), snapAgeP90: Math.round(ageP90), starvedPct: +starvedPct.toFixed(3), rejectedSnaps,
       owned: api.owned, pending: sentHist.length, stateKeys: stateMap.size,
       peers: peers.size, reconnects, promotions, round: roundInfo ? roundInfo.n : null,
+      decides: { asked: decideStats.asked, ai: decideStats.ai, local: decideStats.local, floor: decideStats.floor, msP50: [...decideStats.ms].sort((x, y) => x - y)[Math.floor(decideStats.ms.length / 2)] ?? null },
     };
   }
   function notifyStats(force: boolean): void {
@@ -2185,6 +2247,26 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
       return { a: newest, b: newest, alpha: 1, renderT, starved: 0 };
     },
     latest() { return buf.length ? buf[buf.length - 1] as Snapshot<S> : null; },
+    decide(state, questions, o = {}) {
+      const t0 = wall();
+      const floor = (): Decided => {
+        let picks: DecidePicks = {};
+        try { picks = o.floor ? o.floor(state) ?? {} : {}; } catch { picks = {}; }
+        return { by: 'floor', picks, ms: Math.round(wall() - t0) };
+      };
+      decideStats.asked += 1;
+      const now0 = wall();
+      const why = role !== 'host' ? 'not-host' : offline || !connected ? 'offline' : now0 < decideOffUntil ? 'off' : now0 < decideNextAt ? 'pace' : null;
+      if (why) { decideStats.floor += 1; return Promise.resolve({ ...floor(), why }); }
+      decideNextAt = now0 + 3000;
+      const n = `d${(decideSeq += 1).toString(36)}`;
+      return new Promise<Decided>((done) => {
+        const ms = Math.max(200, Math.min(5000, Number(o.ms) || 2500));
+        const timer = setTimeout(() => { if (deciding.delete(n)) { decideStats.floor += 1; done({ ...floor(), why: 'slow' }); } }, ms);
+        deciding.set(n, { done, timer, at: t0, floor });
+        if (!raw({ t: 'decide', n, state, questions })) { deciding.delete(n); clearTimeout(timer); decideStats.floor += 1; done({ ...floor(), why: 'offline' }); }
+      });
+    },
     stats: statsNow,
     expose(p) { probes = { ...probes, ...p }; },
     close() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homie-rocks/studio",
-  "version": "0.24.2",
+  "version": "0.24.4",
   "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/shop/SELLING.md

@@ -74,6 +74,22 @@ referral share you published in `shop.json` (10% if you kept the suggestion; 0 i
 shows what you owe and to whom, and signs a monthly statement for each. **They invoice you, and you pay them
 yourself.** Nothing moves through Homie.
 
+## What you do, and what your AI does
+
+Your AI sets the shop up with Stripe's own tools for AI (Stripe's agent plugin: its MCP server and skills). It
+makes your products in Stripe, checks your tax settings, makes the webhook, and answers "how are sales?" by reading
+your Stripe. What stays yours, in Stripe's own pages:
+
+- making the Stripe account, and later activating it (your business details, bank account and identity checks);
+- one sign-in page that lets your AI use Stripe's tools: give it your **sandbox** (test) first;
+- one restricted key you make in Stripe and paste into a page on your own computer (never into a chat);
+- approving anything Stripe asks you to confirm (a refund your AI asked Stripe for, for example), and every refund
+  in your office.
+
+If your AI's app cannot use Stripe's sign-in page, Stripe offers an "Agent" key for it instead. From 31 October 2026
+Stripe's tools for AI accept only those (or the sign-in page). The shop's own key is a different, ordinary
+restricted key; never make that one an Agent key, or Stripe will hold every refund for a second approval.
+
 ## Before the first real sale
 
 1. Make (or pick) your Stripe account, verify it, and add a bank account.

package/shop/SHOP.md

@@ -1,6 +1,7 @@
 # The shop: selling in a studio's games with the studio's own Stripe
 
-`@homie-rocks/studio` 0.24.0. A studio sells items for its games through **its own Stripe account**. The studio
+`@homie-rocks/studio` 0.24.0, set up with Stripe's own agent tools since 0.24.3. A studio sells items for its games
+through **its own Stripe account**. The studio
 is the seller; homie.rocks never holds, routes or settles its money, is not a Stripe Connect platform, and takes
 no cut. There is no shared currency between studios. `SELLING.md` beside this file is the owner's plain-words
 note on what selling means for them (refunds, disputes, tax, kids; not legal advice).
@@ -40,6 +41,7 @@ At the studio's root, reviewed in git. Nothing secret is ever in it.
 | `items[].advantage` | `true` when it changes how the game plays: never offered, and never counted as owned, on a beginner or kids server. |
 | `items[].taxCode` | a Stripe product tax code. Managed Payments needs one: by default `txcd_10201000` (video games, downloaded, permanent) or `txcd_10201001` (limited time). |
 | `referrals` | what this studio pays a referrer for a new player's purchase (left out: nothing). |
+| `catalog` | where the items are Products in Stripe: `["test"]`, `["test", "live"]`. `homie-studio shop catalog` writes it once Stripe's catalog matches; the Worker's checkouts then name each item's Product (0.24.3). |
 
 `homie-studio shop check`, and every `homie-studio build`, refuse: anything that names chance, odds, random, a
 crate, a box, a mystery, loot, a gacha, a spin or a roll; fields for odds or drop pools; a countdown, timer or
@@ -107,23 +109,59 @@ homie.rocks: not involved at any step.
 - Each Checkout Session says beside the pay button that the item is delivered at once (the EU and UK withdrawal
   acknowledgement) and that an unused item can still be refunded.
 
-## Setting it up (Claude does the commands; the owner only uses pages)
+## Setting it up (the AI does the commands; the owner only uses Stripe's pages and one page here)
+
+The AI works with **Stripe's own agent tools** (0.24.3): Stripe's agent plugin (`npm install -g @stripe/cli@latest &&
+stripe agent setup`: Stripe's MCP server at `https://mcp.stripe.com` and Stripe's skills, for Claude Code and Codex) or
+Stripe's connector in the Claude app. The owner signs it in once on Stripe's consent page and gives it **a sandbox
+first**. An agent that cannot do OAuth uses an **Agent key** (a restricted key Stripe tags "Agent") from its
+environment; from **2026-10-31** Stripe's MCP refuses full secret keys and restricted keys without that tag. The shop's
+own key, in the Worker, is a plain restricted key and is not affected.
+
+What only the owner does: make the Stripe account and (for live) activate it: business details, bank, identity, and,
+for Managed Payments, its terms and Stripe's eligibility review; approve Stripe's sign-in page; make **one restricted
+key** in Stripe's Dashboard (Stripe has no API that makes API keys) and paste it on the connect page; approve any
+write Stripe sends to them for confirmation (a refund through Stripe's MCP, for one).
 
 1. `npx --no-install homie-studio shop init --supporter` (shop.json and SELLING.md), then `shop check`, commit,
    `npm run deploy` (it applies migration `0008_studio_shop.sql`; the shop stays closed).
-2. In Stripe (the owner): a restricted key with **Checkout Sessions: Write, Charges: Write (refunds),
-   PaymentIntents: Read, Disputes: Read**, and a webhook endpoint at `https://<site>/api/shop/hook` for
-   `checkout.session.completed`, `checkout.session.async_payment_succeeded`, `checkout.session.async_payment_failed`,
-   `checkout.session.expired`, `charge.refunded`, `refund.created`, `refund.updated`, `charge.dispute.created`,
-   `charge.dispute.closed`.
-3. `npx --no-install homie-studio shop connect`: a page on the owner's computer (127.0.0.1, one use, ten minutes)
-   with those steps, both fields and the seller choice (the studio, or Stripe Managed Payments, with what each
-   costs and does). The key and the secret go straight to the Worker secrets `STRIPE_KEY` and
-   `STRIPE_WEBHOOK_SECRET` on Wrangler's standard input. Test keys only, unless `--live`.
-4. `homie-studio shop` says whether anything is still missing. Buy your own item with a Stripe test card, and
-   refund it from `/_studio/office/shop`.
-
-Never ask for a key in a chat, never put one in a file, an argument, a log or a commit.
+2. **The catalog**, through Stripe's MCP: `homie-studio shop catalog` names the one read to make
+   (`stripe_api_read GET /v1/products`, expanding each default price); `homie-studio shop catalog --have <the saved
+   answer>` lists exactly the `stripe_api_write` calls still needed: each item a Product with the id
+   `homie_<studio slug>_<item id>` (the same in a sandbox and live), its name, blurb, a tax code (video games,
+   downloaded: `txcd_10201000`, or `txcd_10201001` for an item that lasts days or ends on a date; eligible for
+   Managed Payments) and metadata naming the studio and the item, with a default Price of shop.json's amount (a tip:
+   the Product only). A changed price is a new Price made the default; an item gone from shop.json is archived, never
+   deleted; a product the studio did not make is never named. When Stripe matches, it says so and writes
+   `"catalog": ["test"]` into shop.json (commit, deploy). shop.json's checked price is always what is charged; the
+   checkout names the Product so Stripe's Dashboard, reports and MCP see sales by product, and a Product missing in
+   this mode falls back to the item described inline.
+3. **Tax**, read through Stripe's MCP: `GET /v1/tax/settings` (with the studio as the seller, Stripe Tax needs
+   `status: active`, the business address, or checkouts fail) and `GET /v1/tax/registrations` (none: Stripe Tax
+   collects nothing anywhere until the owner registers somewhere). Reading only; the owner and their accountant decide.
+4. `npx --no-install homie-studio shop connect`: a page on the owner's computer (127.0.0.1, one use, ten minutes). The
+   owner makes one restricted key with **Checkout Sessions: Write, Charges: Write (refunds), PaymentIntents: Read,
+   Disputes: Read, Webhook Endpoints: Write**, not an Agent key, and pastes it. With it the page reads once (a typo is
+   caught here), **makes the webhook** at `https://<site>/api/shop/hook` for `checkout.session.completed`,
+   `checkout.session.async_payment_succeeded`, `checkout.session.async_payment_failed`, `checkout.session.expired`,
+   `charge.refunded`, `refund.created`, `refund.updated`, `charge.dispute.created`, `charge.dispute.closed` (API version
+   `2025-03-31.basil`, metadata `homie: shop-v1`), and puts the key and the webhook's signing secret, which Stripe hands
+   back once, straight into the Worker secrets `STRIPE_KEY` and `STRIPE_WEBHOOK_SECRET` on Wrangler's standard input.
+   An older endpoint the kit made for the same address is turned off, never deleted. The page offers the seller
+   choice (the studio, or Stripe Managed Payments, with what each costs and does) and, in test mode with Managed
+   Payments, tries one test checkout with it (expired at once) and says whether Stripe took it. Afterwards the owner
+   may set the key's Webhook Endpoints back to None (recommended; the shop never needs it again). A key without
+   Webhook Endpoints: the page takes a webhook signing secret the owner made and revealed in Stripe instead. Test keys
+   only, unless `--live`.
+5. `homie-studio shop` says whether anything is still missing. Buy your own item with a Stripe test card, and
+   refund it from `/_studio/office/shop`. Through Stripe's MCP, `GET /v1/webhook_endpoints` shows the endpoint the
+   page made (its `we_…` id): if it is not there, the MCP is signed in to another account or sandbox than the key.
+6. **Live**, only when the owner says so: they activate the account, give Stripe's MCP access to the live account,
+   `shop catalog --mode live` makes the live catalog the same way, and `shop connect --live` takes a live key.
+
+Never ask for a key in a chat, never put one in a file, an argument, a log or a commit. **Never make a webhook endpoint
+or event destination through Stripe's MCP**: its answer carries the signing secret into the conversation (in Claude
+Code the Homie mod refuses the call). Never use a Stripe CLI login or a key found on the computer.
 
 ## The office
 
@@ -133,6 +171,15 @@ to the studio's own Stripe Dashboard, a CSV for the accountant, and the referral
 refund (`POST /_studio/api/shop/refund`, `homie-studio shop refund <order>`) is always an ASK the owner confirms
 with one tap; so is marking a referrer paid.
 
+A refund made anywhere else (in Stripe's Dashboard, or through Stripe's MCP after the owner approved Stripe's own
+confirmation link) reaches the shop as `refund.created` / `charge.refunded`, and the item leaves the player's account
+the same way. If the Worker's key is an Agent key, Stripe holds the Worker's refunds for a person's approval
+(`approval_required`): the office answers 202 "held", nothing changes until someone approves it in Stripe (Settings,
+Approvals), and the webhook finishes it. Reconnect with a plain restricted key to get the one tap back.
+
+"How are sales?": `homie-studio shop` and `shop orders` (the studio's own books, no names), and through Stripe's MCP,
+read-only, `stripe_analytics` or `stripe_api_read` on the balance, payouts and checkout sessions.
+
 ## Referrals
 
 - A link with `?via=<host>` (another studio, homie.rocks, anywhere) opened by a person whose browser has never
@@ -150,5 +197,7 @@ with one tap; so is marking a referrer paid.
 ## Testing without money
 
 The kit's tests run the Worker against `stripe-mock` (Stripe's open-source API mock, which checks every parameter
-against Stripe's own API description) and sign webhooks with a test secret. `STRIPE_API_BASE` (a loopback address
+against Stripe's own API description) and sign webhooks with a test secret. stripe-mock also takes every write
+`shop catalog` lists, a checkout that names its Product, and the webhook the connect page makes. Stripe's MCP is
+never called by the tests: `shop catalog --have` reads an answer in the shapes Stripe's API documents. `STRIPE_API_BASE` (a loopback address
 only) points a Worker at such a mock; it is never honoured for anything but 127.0.0.1 or localhost.

package/starters/ember-vale/game.json

@@ -7,6 +7,7 @@
   "entry": "src/main.ts",
   "netplay": { "v": 1, "public": true, "movement": "owner" },
   "saves": true,
+  "decide": false,
   "landing": {
     "pitch": "Your hero keeps every level. The night does not.",
     "howToPlay": [

package/starters/ember-vale/src/main.ts

@@ -43,7 +43,7 @@
  * The take "strike" (lab.json) stands a big training slime in front of the hero (lab.stage "dummy"). Outside the lab
  * every lab call is a no-op.
  */
-import { AI_MARK, BUBBLE_FONT, createBubbles, createControls, createLabels, createRoom, paintBubbles, type BubbleIn, type BubbleOut, createSaves, easeView, exposePort, fitView, jitter, q, standoff, stripAi, type BodyBase, type Fit, type LabelIn, type LabelOut, type NetEvent, type Skill } from '@homie-rocks/studio/port';
+import { AI_MARK, BUBBLE_FONT, createBubbles, createControls, createLabels, createRoom, paintBubbles, type BubbleIn, type BubbleOut, createSaves, easeView, exposePort, fitView, jitter, q, standoff, stripAi, type BodyBase, type DecidePicks, type Fit, type LabelIn, type LabelOut, type NetEvent, type Skill } from '@homie-rocks/studio/port';
 import { useAgents, type Goal, type Vocabulary } from '@homie-rocks/studio/agents';
 import vocabulary from '../agents.json';
 // The Game Lab: tunables, phases, tracks and overlays (no-ops outside the lab).
@@ -376,12 +376,66 @@ function stepHost(dt: number): void {
     b.flags = now - b.strikeAt < T.flashMs ? STRIKING : 0;
     if (wants && live && now - b.atkAt > T.strikeMs) strike(b, now);
   }
-  if (live) stepSlimes(dt, now);
+  if (live) { stepDirector(now); stepSlimes(dt, now); }
   // Every browser's ask buttons offer the quests open now (slow keyed state: sent only when it changes).
   net.state('quests', openQuests());
   room.update();
 }
 
+/* ------------------------------------------------------------------ the slimes' director (section 20, opt-in) */
+/**
+ * Every 6 s of a live night the host asks the studio's decision model how the slimes should hunt (`net.decide`: Clef,
+ * three typed questions, never text): a tactic, whether a wave comes now, how hard to push. It runs only when game.json
+ * says "decide": true (the room answers "off" otherwise, and asks are spent from the studio's AI brains' day); without it,
+ * over budget or slow, the floor answers: chase, no wave, steady, which is how the vale always played. On a kids server
+ * the slimes never gang up on the most hurt hero and the vale never pushes past steady. The heroes' dial is untouched:
+ * this is the slimes' mind, not the bots'.
+ */
+type Tactic = 'chase' | 'surround' | 'weakest' | 'regroup';
+const TACTICS: Record<Tactic, string> = {
+  chase: 'Rush the nearest hero',
+  surround: 'Spread out and close in on a hero from every side',
+  weakest: 'Gang up on the most hurt hero',
+  regroup: 'Fall back to the King Slime and gather before the next push',
+};
+/** How often a slime comes, by pressure (0 a breather .. 4 fierce). 1100 ms at 2 is the vale as it always was. */
+const SPAWN_MS = [1900, 1450, 1100, 850, 700];
+const DIRECTOR_MS = 6000;
+const director = { tactic: 'chase' as Tactic, pressure: 2, waveLeft: 0, by: 'floor', at: 0, asking: false, log: [] as Record<string, unknown>[] };
+const directorFloor = (): DecidePicks => ({ tactic: 'chase', wave: false, pressure: 2 });
+function stepDirector(now: number): void {
+  if (!room.hosting || director.asking || now < director.at) return;
+  director.at = now + DIRECTOR_MS;
+  director.asking = true;
+  const kidsRoom = kids();
+  const king = slimes.find((o) => o.size === 3);
+  const heroes = [...room.bodies.values()].filter((b) => !b.bot && b.seat !== null);
+  const state = {
+    heroes: heroes.map((b) => ({ hp: Math.round((100 * b.hp) / Math.max(1, b.maxHp)), down: Boolean(b.flags & DOWN), level: b.level, nearKing: king ? Math.round(Math.hypot(king.x - b.x, king.y - b.y)) : null })),
+    slimes: { count: slimes.length, big: slimes.filter((o) => o.size === 2).length, king: king ? Math.round((100 * king.hp) / king.maxHp) : null },
+    night: { secondsLeft: room.clock().secondsLeft }, now: { tactic: director.tactic, pressure: director.pressure },
+    ...(kidsRoom ? { note: 'Young players: keep it gentle' } : {}),
+  };
+  const tactics = Object.fromEntries(Object.entries(TACTICS).filter(([k]) => !(kidsRoom && k === 'weakest')));
+  const asked = performance.now();
+  void net.decide(state, {
+    tactic: { type: 'choice', instructions: 'How should the slimes hunt the heroes for the next few seconds? A fun fight, not a massacre: hurt heroes deserve a breather.', criteria: tactics },
+    wave: { type: 'noul', instructions: 'Should a wave of extra slimes come now?', criteria: { true: 'The heroes are healthy and it has gone quiet', false: 'The heroes are hurt, down or few' } },
+    pressure: { type: 'score', instructions: 'How hard should the vale push the heroes right now?', criteria: ['A breather', 'Easy', 'Steady', 'Hard', 'Fierce'] },
+  }, { floor: directorFloor }).then((d) => {
+    director.asking = false;
+    const t = String(d.picks['tactic'] ?? 'chase') as Tactic;
+    director.tactic = t in tactics ? t : 'chase';
+    director.pressure = clamp(Math.round(Number(d.picks['pressure'] ?? 2)), 0, kidsRoom ? 2 : 4);
+    if (d.picks['wave'] === true && director.waveLeft === 0) director.waveLeft = 3;
+    director.by = d.by;
+    director.log.push({ at: Date.now(), by: d.by, why: d.why ?? null, ms: Math.round(performance.now() - asked), tactic: director.tactic, pressure: director.pressure, wave: d.picks['wave'] === true });
+    if (director.log.length > 40) director.log.shift();
+    // Every screen sees what the slimes are up to (only when a model decided; the floor is the vale as always).
+    net.state('slimes', d.by === 'floor' ? null : { tactic: director.tactic, pressure: director.pressure });
+  });
+}
+
 /* ------------------------------------------------------------------ the guides' hands */
 const bodyOfSeat = (seat: unknown): Body | null => { for (const o of room.bodies.values()) if (!o.bot && o.seat === seat) return o; return null; };
 const people = (): Body[] => [...room.bodies.values()].filter((o) => !o.bot && o.seat !== null && !(o.flags & DOWN));
@@ -498,8 +552,11 @@ function stepSlimes(dt: number, now: number): void {
   if (lab.stage === 'dummy') return; // the lab's training slime stands still and never bites
   const bodies = [...room.bodies.values()].filter((b) => !(b.flags & DOWN));
   const people = bodies.filter((b) => !b.bot).length;
-  if (now >= spawnAt && slimes.length < 6 + people * 2) {
-    spawnAt = now + 1100;
+  // The director's pressure (0 a breather .. 4 fierce; 2 is how the vale always played) sets how fast and how many.
+  const cap = Math.max(4, 6 + people * 2 + (director.pressure - 2) * 2) + (director.waveLeft > 0 ? 3 : 0);
+  if ((now >= spawnAt || director.waveLeft > 0) && slimes.length < cap) {
+    spawnAt = now + SPAWN_MS[director.pressure]!;
+    if (director.waveLeft > 0) director.waveLeft -= 1;
     const edge = Math.floor(Math.random() * 4);
     const x = edge === 0 ? 30 : edge === 1 ? W - 30 : Math.random() * W;
     const y = edge === 2 ? 30 : edge === 3 ? H - 30 : Math.random() * H;
@@ -517,10 +574,18 @@ function stepSlimes(dt: number, now: number): void {
     if (struck.has(s.id)) continue;
     let target: Body | null = null; let bd = Infinity;
     for (const b of prey) { const d = Math.hypot(b.x - s.x, b.y - s.y); if (d < bd) { bd = d; target = b; } }
+    // The director's tactic (section 20; chase is how the vale always played): the most hurt hero, a ring round the
+    // nearest, or back to the King to gather (a hero close by is still bitten).
+    if (director.tactic === 'weakest' && prey.length > 1) target = prey.reduce((a, b) => (b.hp / b.maxHp < a.hp / a.maxHp ? b : a));
     const speed = s.size === 3 ? 70 : 95 - s.size * 10;
     if (target) {
-      const dx = target.x - s.x; const dy = target.y - s.y; const dist = Math.hypot(dx, dy) || 1;
-      s.x += (dx / dist) * speed * dt; s.y += (dy / dist) * speed * dt;
+      let gx = target.x; let gy = target.y;
+      const king = slimes.find((o) => o.size === 3);
+      if (director.tactic === 'surround' && bd > 90) { const a = s.id * 2.39996; gx += Math.cos(a) * 80; gy += Math.sin(a) * 80; }
+      if (director.tactic === 'regroup' && king && s !== king && bd > 140) { gx = king.x + Math.cos(s.id) * 70; gy = king.y + Math.sin(s.id) * 70; }
+      const dx = gx - s.x; const dy = gy - s.y; const dist = Math.hypot(target.x - s.x, target.y - s.y) || 1;
+      const step = Math.hypot(dx, dy) || 1;
+      if (step > 4) { s.x += (dx / step) * speed * dt; s.y += (dy / step) * speed * dt; }
       if (dist < R + 10 + s.size * 10 && now - s.hitAt > 800) {
         s.hitAt = now;
         target.hp -= 5 * s.size + (s.size === 3 ? 10 : 0);
@@ -919,6 +984,13 @@ function hud(t: number): void {
   // Top centre; on a narrow screen where that would touch the panel, just under it.
   if (x0 + pw + 10 > cw / 2 - ctx.measureText(clock).width / 2) { ctx.textAlign = 'left'; ctx.fillText(clock, x0 + 10, y0 + 62 + 20); }
   else { ctx.textAlign = 'center'; ctx.fillText(clock, cw / 2, 30); }
+  // What the slimes are up to, when the studio's decision model chose it (section 20; nothing shows on the floor).
+  const mind = c.phase === 'live' ? net.stateOf<{ tactic: string; pressure: number }>('slimes') : null;
+  if (mind) {
+    const words: Record<string, string> = { chase: 'rushing you', surround: 'closing in from every side', weakest: 'hunting the hurt', regroup: 'gathering round the King' };
+    ctx.font = SMALL; ctx.fillStyle = '#e7a86b'; ctx.textAlign = 'center';
+    ctx.fillText(`Slimes: ${words[mind.tactic] ?? mind.tactic}`, cw / 2, x0 + pw + 10 > cw / 2 - 80 ? y0 + 62 + 40 : 50);
+  }
   ctx.textAlign = 'center';
   if (c.phase === 'over') {
     const rows = room.results().slice(0, 5);
@@ -1144,6 +1216,8 @@ net.expose({
     me: me.has ? { x: Math.round(me.x), y: me.y | 0 } : null,
     log: guideLog.slice(),
   }),
+  // The slimes' director (section 20): its tactic now, and each decision (who answered, how long it took).
+  director: () => ({ tactic: director.tactic, pressure: director.pressure, by: director.by, log: director.log.slice(), net: net.stats().decides ?? null }),
   // Where the camera looks, and the names as drawn (the e2e probe counts overlaps, checks your own, and reads them).
   camera: () => (cam ? { x: cam.x, y: cam.y, scale: cam.scale, follow: cam.follow } : null),
   labels: () => shownLabels.map((l) => ({ text: l.text, self: Boolean(l.self), alpha: l.alpha, moved: l.moved, left: Math.round(l.left), top: Math.round(l.top), right: Math.round(l.right), bottom: Math.round(l.bottom) })),