@homie-rocks/studio 0.24.3 → 0.24.5

package/CHANGELOG.md

@@ -17,9 +17,59 @@ 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.24.5] - 2026-10-03
+
+**Plugin 0.25.5** · [#39](https://github.com/homie-rocks/homie/pull/39)
+
+Room chat keeps off your game's HUD: on a phone the Chat pill is a round icon, as the room button is, and your game can say where the strip of new lines sits, or keep new lines in the Chat sheet, so a game with a busy HUD keeps typed chat.
+
+### Added
+
+- game.json `"screen": { "chat": … }` says where room chat's strip of new lines sits on each screen: `at` (a corner, `top-center` or `bottom-center`), `x` / `y` to move it in from its side and its edge, and `"lines": "sheet-only"` to keep new lines in the Chat sheet while the pill counts them. `desk`, `phone`, `sideways` and `tv` (the big screen's corner of lines) each take their own, changing only what they name. A game whose HUD or controls sit where the strip shows no longer has to keep chat to emoji to stay clear. `chat/CHAT.md` has every field; the template's AGENTS.md and the game skill say when to use it.
+- `homie-studio build` warns about a wrong field in `screen.chat` (the play page uses the default there), and says so when a place or `"sheet-only"` is written in game.json `"chat"` (the room's rules) instead.
+
+### Changed
+
+- The Chat pill follows the room button: on a phone (either way up), and beside a room button your game keeps an icon (`screen.share` `"label": false`), it is a round icon with the count of new lines on its corner. On a computer it still says "Chat", unless the word would take the room button's band off the screen or into the middle third of its width, where games keep a clock or a title; then it stays the icon until the window changes size.
+
+### Fixed
+
+- On a phone, the Chat pill's word no longer covers the HUD beside the room button: the first digit of a clock, the last letter of a title.
+
+### Upgrade notes
+
+- Nothing to do: a game without `screen.chat` shows the strip where it did. If you kept a game's chat to emoji only so the strip stayed off its HUD, tell Claude: "Put room chat where my game has room, and let players type again." It places the strip with `screen.chat` and resets the game's chat rules (`homie-studio chat rules <game> --reset`).
+
+## [0.24.4] - 2026-10-03
+
+**Plugin 0.25.4** · [#37](https://github.com/homie-rocks/homie/pull/37) · [release-2026-10-03-studio-0.24.4](https://github.com/homie-rocks/homie/releases/tag/release-2026-10-03-studio-0.24.4)
+
+Your AI guides think with Cloudflare's Clef decision model, which does what a player asks; Clef runs on your own computer while you build; and your games can ask it for their own decisions (tactics, a director's call, a turn) in about a quarter of a second.
+
+### Added
+
+- **Clef thinks for your AI guides.** On a server whose guides use Workers AI, the default model is now `@cf/cloudflare/clef-flash`, Cloudflare's open-source decision model (Apache 2.0). It never writes text: each decision is asked as typed Choices of your `agents.json` (which goal, which quest or place or player, which line or none), and its answer is checked by the same rules as before. On 64 recorded Ember Vale moments it did what an open ask asked 36 times out of 40 by itself (the old Llama 3.1 8B: 0 of 40), and blind judges preferred its decisions in 51 of 64 (Llama's in none). In a live room it answered all 9 asks itself.
+- `homie-studio agents try <game> --view <file.json> [--ask ask_help:quest=king-slime --from 0] [--model <id>]`: what your guides' brain would decide in one moment, with no seat taken: the decision, the brain's own pick before the fixed rules, how sure it was, how long it took and what it cost. Use it to test an `agents.json` or to compare a model before setting it.
+- **Clef on your own computer.** With [Ollama](https://ollama.com) 0.35.1 or later and `clef-flash` on this computer, `homie-studio dev` runs the guides, chat review and your game's decisions on it: free, nothing sent to Cloudflare (`--no-local-ai` turns it off). `homie-studio agents sit <game> --brain local` (the MCP's `agent_sit { brain: "local" }`) seats a guide that thinks on your computer every few seconds. `setup status` has a "Clef on this computer" row. Nothing ever downloads the model by itself: `ollama pull clef-flash` is about 11 GB, and it is your call.
+- **Your game's own decisions** (NETPLAY.md section 20): `net.decide(state, questions, { floor })` on the host, for a game whose `game.json` says `"decide": true`. Ask a Choice (2 to 26 options), a yes/no or a Score about your game's state; the room asks Clef and answers with option ids and numbers, within the same daily budget as the guides, at most one ask every 3 s per room. It always answers: with your own floor when there is no AI, no budget, or no answer in time. Measured: about a quarter of a second there and back, about 4 neurons for three questions. Ask per beat or per turn, never per frame.
+- Ember Vale's slimes can think (opt-in: set `"decide": true` in its `game.json`): every 6 s the slimes' director picks how they hunt (rush, surround, gang up on the most hurt, regroup at the King), whether a wave comes and how hard to push, and every screen shows what the slimes are up to. On a kids server they never gang up on the most hurt and never push past steady.
+- The office shows each room's game decisions (how many, who answered, the model's time, the neurons), and each guide decision's model, how sure it was and, when a rule overruled it, what the brain itself chose.
+
+### Changed
+
+- A player's ask is now answered with the values they asked for: a brain that picks the asked goal with another quest or place is overruled, like one that picks another goal.
+- House guides remember the lines they said and who is new to them: they greet a newcomer once and otherwise stay quiet unless asked or something changes.
+- Clef costs more neurons a decision than Llama (about 9 against 4: it reads its questions and answers, and writes nothing), so the default 8,000 a day is about 900 guide decisions. Set `HOMIE_BRAIN_MODEL` to `@cf/meta/llama-3.1-8b-instruct-fp8-fast` in `wrangler.jsonc` to keep the old model.
+- The doctor's Workers AI check asks Clef one yes/no question (it does not take a chat message).
+
+### Upgrade notes
+
+- `npm run deploy` after upgrading: guides on Workers AI switch to Clef at their next decision. Nothing else to do.
+- To try local Clef, install Ollama (0.35.1 or later), say yes to the download, and run `ollama pull clef-flash`; then `npm run dev`.
+
 ## [0.24.3] - 2026-10-03
 
-**Plugin 0.25.3** · [#36](https://github.com/homie-rocks/homie/pull/36)
+**Plugin 0.25.3** · [#36](https://github.com/homie-rocks/homie/pull/36) · [release-2026-10-03-studio-0.24.3](https://github.com/homie-rocks/homie/releases/tag/release-2026-10-03-studio-0.24.3)
 
 Set up your shop with Stripe's own tools for AI: your AI makes the products, checks tax, makes the webhook and answers "how are sales?"; you make the account, approve Stripe's pages and paste one key.
 

package/README.md

@@ -284,8 +284,21 @@ npx homie-studio agents pass night-rush --label Claude
   day); with none, the game's scripted floor. The local MCP's `agent_sit` puts the owner's own Claude in a guide's
   seat. The AI never types: it picks ids; the room drops anything else.
   [agents/GUIDES.md](agents/GUIDES.md) is the short path for an existing RPG.
+- **Clef thinks for the guides** (0.24.4): Workers AI's default for them is Cloudflare's decision model
+  (`@cf/cloudflare/clef-flash`), which answers a decision as typed Choices (goal, values, 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: none) and blind
+  judges preferred it in 51 of 64, at about 9 neurons a decision (Llama: 4). `HOMIE_BRAIN_MODEL` still picks Llama or
+  the 27B Clef; `agents try <game> --view <file> [--ask …] [--model …]` shows what the brain would decide in a moment.
+- **Clef on your own computer** (0.24.4): with Ollama and `clef-flash` here, `dev` runs the guides, chat review and
+  game decisions on it, free and with no Cloudflare, and `agents sit --brain local` (the MCP's `agent_sit { brain:
+  "local" }`) seats a guide that thinks here. Nothing downloads it: `ollama pull clef-flash` is about 11 GB, the
+  person's choice (doctor's "Clef on this computer" row says what is there).
+- **A game's own decisions** (0.24.4, NETPLAY.md section 20): `net.decide(state, questions, { floor })` on the host,
+  for a game whose game.json says `"decide": true`: tactics for its opponents, an NPC's reaction, a director's call,
+  a turn's move, answered by Clef in the room in about a quarter of a second, per beat (never per frame), within the
+  AI brains' day; the floor answers whenever it cannot. Ember Vale's slimes pick their tactics this way (opt-in).
 - Everything is in the studio's own Worker and D1 (migration `0006_studio_servers.sql`). The site's side is in
-  [site/SITE.md](site/SITE.md); the room's in [netplay/NETPLAY.md](netplay/NETPLAY.md) sections 17 and 18.
+  [site/SITE.md](site/SITE.md); the room's in [netplay/NETPLAY.md](netplay/NETPLAY.md) sections 17, 18 and 20.
 
 ## Room chat
 
@@ -303,8 +316,9 @@ npx homie-studio chat remove night-rush pub-3 <line id>                 # take a
 npx homie-studio chat words                                             # the built-in word list the floor holds
 ```
 
-- **The play page:** a Chat pill beside the room button (the corner `screen.share` keeps clear of the HUD), its
-  sheet (the last minutes, the reactions, the quick lines, typing, Report), a short ticker of new lines, and two
+- **The play page:** a Chat pill beside the room button (the corner `screen.share` keeps clear of the HUD; a round
+  icon on a phone), its sheet (the last minutes, the reactions, the quick lines, typing, Report), a short strip of
+  new lines (game.json `screen.chat` puts it where the game has room, or keeps new lines in the sheet), and two
   switches each player keeps: "Show my messages over my character" and "Show chat on this screen". The big screen
   shows the lines in a corner; the watch page has a Chat button; homie.rocks shows a room's chat on its card.
 - **Rules** per game (game.json `"chat"`) and per server, in the office or with `chat rules`: off, emoji, quick
@@ -314,7 +328,8 @@ npx homie-studio chat words                                             # the bu
 - **Moderation, in the studio's own Worker, before anyone sees a typed line:** a built-in word list and patterns
   (slurs, sexual words, self-harm, personal questions and contact details, links, swears, your own words), then
   Cloudflare's **Clef** decision model on the studio's own Workers AI (`@cf/cloudflare/clef-flash`, about 2.3
-  neurons a message measured, 2,000 a day by default: inside the free allocation). Emoji and quick lines are never reviewed.
+  neurons a message measured, 2,000 a day by default: inside the free allocation; under `dev`, Clef on this computer
+  when Ollama has it, free). Emoji and quick lines are never reviewed.
 - **The owner:** every live room's last minutes in the office with Remove, Mute and Kick (from a line, with their
   lines taken down), the same in the owner's own game, the reports players make, and Announce (a studio line).
 - **Speech bubbles:** `net.on('say')` and the port kit's `createBubbles` / `paintBubbles`; Gem Rush, Ember Vale and
@@ -366,7 +381,8 @@ connector (the AI says whether its Homie tools are there; the directory is reach
 with the studio's own Wrangler, and the account's email verified: a deploy that went through proves it, a
 deploy refused for it is remembered), Chrome for the checks, ffmpeg, and the optional GitHub, ElevenLabs and
 fal (and, in Claude Code, the status line); in a studio that sells (shop.json), a Stripe row: whether Stripe's own
-agent plugin (its MCP server) is set up for this AI, with `stripe agent setup` as the fix (0.24.3). Each row is green, missing or "do this now", says what it
+agent plugin (its MCP server) is set up for this AI, with `stripe agent setup` as the fix (0.24.3); and in a studio, whether Clef is on this
+computer (Ollama with `clef-flash`, optional, never downloaded without the person's yes) (0.24.4). Each row is green, missing or "do this now", says what it
 unlocks, and gives the exact fix: a command the AI runs or a page the person taps. It only reads, answers in
 seconds, and never prints a key, a token or an account's name or id. A studio the Claude app's setup card made
 (`setup attach`) counts as connected to Cloudflare and GitHub there. `--json` gives the rows.

package/agents/GUIDES.md

@@ -10,8 +10,8 @@ Vale (`homie-studio game new <id> --from ember-vale`) is the worked example.
 - A beginner server whose AI guide seats (always marked "· AI") follow new heroes, lead them to places, take on a
   quest with them, and pull back when asked.
 - **Hands** are your game's own bot code, every frame, at the party's skill dial. **The brain** picks a goal every
-  few seconds: the studio's own Workers AI, the owner's own key, or the owner's Claude in a seat. With none of them
-  (or over the day's budget) your scripted `decide` plays.
+  few seconds: the studio's own Workers AI (Clef), the owner's own key, or the owner's Claude in a seat. With none
+  of them (or over the day's budget) your scripted `decide` plays.
 - The AI never types. It chooses ids from your `agents.json`; your game draws your own words.
 
 ## 1. Upgrade
@@ -86,10 +86,17 @@ const agents = useAgents(room.net, vocab as unknown as Vocabulary, {
 
 1. `homie-studio servers new <id> "First Steps" --policy beginner --guides 2` (add `--kids` for children).
 2. `homie-studio agents brain <id> first-steps workers-ai`: the first time is an ASK the owner taps; then
-   `npm run deploy` once (it binds Workers AI). The free allocation (10,000 neurons a day) gives about six busy
-   guide-hours; the default budget is 8,000. Or `owner-key` with `agents brain key` on the owner's own computer.
-3. Try it: two browsers on the server's page, walk up to a guide, tap "Help me with ...". In a terminal or the
-   local MCP, `agent_sit { game: "<id>", server: "first-steps" }` puts your own Claude in a guide's seat.
+   `npm run deploy` once (it binds Workers AI). The guides think with Cloudflare's Clef decision model
+   (`@cf/cloudflare/clef-flash`, the default since 0.24.4): it answers each decision as typed Choices of your
+   goals, values and lines, so it does what an ask asks far more often than a chat model did. About 9 neurons a
+   decision: the default budget of 8,000 a day is about 900 decisions (the free allocation is 10,000). Or
+   `owner-key` with `agents brain key` on the owner's own computer.
+3. Try it: `homie-studio agents try <id> --view view.json --ask ask_help:quest=<quest> --from 0` shows what the
+   brain would decide in that moment (with `--model` to compare one). Then two browsers on the server's page, walk
+   up to a guide, tap "Help me with ...". In a terminal or the local MCP, `agent_sit { game: "<id>", server:
+   "first-steps" }` puts your own Claude in a guide's seat; `brain: "local"` lets Clef on your computer decide.
+   Under `npm run dev` the guides think with Clef on your own computer when Ollama has `clef-flash` (free; it is
+   about 11 GB and only ever downloaded when you say so: `ollama pull clef-flash`).
 
 ## 5. Do not
 

package/bin/homie-studio.mjs

@@ -18,8 +18,10 @@
  *   homie-studio games
  *   homie-studio build [<id>] [--maps]   (--maps: also keep each bundle's source map and module sizes in .studio/maps/<id>/,
  *                                          never in site/dist: what `perf` reads a CPU profile through)
- *   homie-studio dev [--port 8787] [--remote-ai]   (--stop: stop exactly this studio's dev server, nothing else;
- *                                         AI guides think scripted here unless --remote-ai: real Workers AI, billed)
+ *   homie-studio dev [--port 8787] [--remote-ai] [--no-local-ai]   (--stop: stop exactly this studio's dev server, nothing else;
+ *                                         AI guides, chat review and game decisions think with Clef on this computer
+ *                                         when Ollama has clef-flash (free; dev never downloads it), else scripted;
+ *                                         --remote-ai: the real Workers AI, billed)
  *   homie-studio check <id> [--url <site>] [--shots <dir>]
  *   homie-studio perf <id> [--url <site>] [--device computer,phone] [--runs 1] [--seconds 15] [--warm 3] [--profile]
  *                     [--cpu 4] [--out <dir>] [--max-load 0.8] [--pair <label>]
@@ -121,6 +123,11 @@
  *                                          time AI guides may talk are ASKED for, like office kick; --budget is
  *                                          Workers AI neurons a day, or dollars a day for the owner's key)
  *   homie-studio agents brain key [--remove]   (the owner's AI key, typed into a page on this computer only)
+ *   homie-studio agents sit <game> [--server <id>] [--brain local]   (a guide's seat from this terminal; --brain local:
+ *                                          Clef on this computer decides every few seconds, free; never downloads it)
+ *   homie-studio agents try <game> --view <file.json> [--ask <ask>[:<arg>=<value>] --from <seat>] [--model <id>]
+ *                                         (what the guides' brain would decide in that moment, with no seat taken;
+ *                                          spent from the guides' day; --model compares a model before setting it)
  *   homie-studio shop                     is the studio's shop selling (its own Stripe), and if not, what is missing
  *   homie-studio shop init [--supporter] [--currency usd] [--price 500] [--managed]   shop.json and SELLING.md
  *   homie-studio shop check               shop.json against the kit's rules (real money, nothing random, the kids rules)
@@ -245,7 +252,8 @@ import { statsKey, statsLink, statsRevoke, statsShare, statsShow } from '../lib/
 import { playersOwner, playersShow } from '../lib/players.mjs';
 import { officeAnnounce, officeClose, officeInvite, officeKey, officeKick, officeLaunch, officeLines, officeLink, officeMute, officeRevoke, officeShow } from '../lib/office.mjs';
 import { chatBudget, chatLines, chatRemove, chatRulesSet, chatShow, chatWords } from '../lib/chat-cli.mjs';
-import { agentsBrain, agentsBrainKey, agentsPass, agentsPasses, agentsRevoke, serversClose, serversLevel, serversLines, serversList, serversMember, serversNew, serversSet } from '../lib/servers.mjs';
+import { detectLocalAi, localAiVars } from '../lib/local-ai.mjs';
+import { agentsBrain, agentsBrainKey, agentsPass, agentsPasses, agentsRevoke, agentsTry, serversClose, serversLevel, serversLines, serversList, serversMember, serversNew, serversSet } from '../lib/servers.mjs';
 import { AgentSeat } from '../lib/agent-seat.mjs';
 import { shopCheck, shopConnect, shopDisconnect, shopInit, shopLines, shopOrders, shopRefund, shopStatements, shopStatus } from '../lib/shop.mjs';
 import { catalogLines, catalogPlan } from '../lib/shop-catalog.mjs';
@@ -263,7 +271,7 @@ import { formatHandoff, handoff } from '../lib/handoff.mjs';
 
 const argv = process.argv.slice(2);
 const flags = new Map();
-const BOOL_FLAGS = ['off', 'revoke', 'json', 'yes', 'detach', 'no-install', 'plan', 'stop', 'share', 'apply', 'diff', 'template', 'ci', 'fresh', 'install', 'remove', 'replace', 'artifact', 'open', 'reopen', 'kids', 'remote-ai', 'dry-run', 'verify', 'maps', 'profile', 'hands-on', 'automatic', 'unlock', 'confirm', 'no-library', 'no-validate', 'rigged', 'supporter', 'managed', 'live', 'send', 'accept-tos'];
+const BOOL_FLAGS = ['off', 'revoke', 'json', 'yes', 'detach', 'no-install', 'plan', 'stop', 'share', 'apply', 'diff', 'template', 'ci', 'fresh', 'install', 'remove', 'replace', 'artifact', 'open', 'reopen', 'kids', 'remote-ai', 'dry-run', 'verify', 'maps', 'profile', 'hands-on', 'automatic', 'unlock', 'confirm', 'no-library', 'no-validate', 'rigged', 'supporter', 'managed', 'live', 'send', 'accept-tos', 'quiet', 'no-local-ai'];
 const positional = [];
 for (let i = 0; i < argv.length; i++) {
   const a = argv[i];
@@ -825,8 +833,9 @@ async function main() {
     if (sub === 'revoke') return agentsRevoke(root, positional[2], { url });
     if (sub === 'brain' && positional[2] === 'key') return agentsBrainKey(root, { remove: flags.has('remove'), log });
     if (sub === 'brain') return agentsBrain(root, positional[2], positional[3], positional[4], { url, budget: flags.get('budget') });
-    if (sub === 'sit') return agentsSit(root, positional[2], { url, server: flags.get('server'), pass: flags.get('pass'), label: flags.get('label') });
-    return { ok: false, command: 'agents', why: `unknown: agents ${sub ?? ''} (pass, passes, revoke, brain, brain key, sit)` };
+    if (sub === 'sit') return agentsSit(root, positional[2], { url, server: flags.get('server'), pass: flags.get('pass'), label: flags.get('label'), brain: flags.get('brain') });
+    if (sub === 'try') return agentsTry(root, positional[2], { url, view: flags.get('view'), ask: flags.get('ask'), from: flags.get('from'), model: flags.get('model'), mode: flags.get('mode'), quiet: flags.has('quiet'), avoid: flags.get('avoid'), players: flags.get('players'), readFile: (f) => readFileSync(resolve(f), 'utf8') });
+    return { ok: false, command: 'agents', why: `unknown: agents ${sub ?? ''} (pass, passes, revoke, brain, brain key, sit, try)` };
   }
   if (cmd === 'media' && sub === 'put') return mediaPut(root, positional[2], flags.get('as'));
   if (cmd === 'media' && sub === 'move') return mediaMove(root, { paths: positional.slice(2), dryRun: flags.has('dry-run') || flags.has('plan'), verify: flags.has('verify'), log });
@@ -1030,9 +1039,17 @@ async function dev(root) {
   log(`Local site: http://127.0.0.1:${port}/  (each game: http://127.0.0.1:${port}/<id>/play — open it in two browsers)`);
   const ai = devConfig(root, flags.has('remote-ai'));
   if (ai.note) log(ai.note);
+  // The person's own Clef (0.24.4, lib/local-ai.mjs): with Ollama and clef-flash on this computer, the local Worker's
+  // guides, chat review and game decisions think here, free. Never a download: dev only says what one would cost.
+  let localVars = [];
+  if (!flags.has('remote-ai') && !flags.has('no-local-ai')) {
+    const found = await detectLocalAi();
+    localVars = localAiVars(found);
+    log(found.ok ? `AI guides, chat review and game decisions think with ${found.model} on this computer (Ollama ${found.version}): free, nothing sent to Cloudflare.` : found.say);
+  }
   // --remote-ai: Wrangler's --local turns every remote binding off ("not supported"), so a dev with the real Workers AI
   // (the guides' brains, room chat's review) runs without it; everything else stays local all the same.
-  const child = spawn(bin, ['dev', ...(flags.has('remote-ai') ? [] : ['--local']), '--ip', '127.0.0.1', '--port', port, ...ai.args], { cwd: workerDir(root), env, stdio: 'inherit' });
+  const child = spawn(bin, ['dev', ...(flags.has('remote-ai') ? [] : ['--local']), '--ip', '127.0.0.1', '--port', port, ...ai.args, ...localVars], { cwd: workerDir(root), env, stdio: 'inherit' });
   mkdirSync(dirname(devFile(root)), { recursive: true });
   writeFileSync(devFile(root), `${JSON.stringify({ pid: process.pid, child: child.pid, port: Number(port), at: new Date().toISOString() })}\n`);
   log(`Stop it with: npx --no-install homie-studio dev --stop   (this studio's dev server only)`);
@@ -1063,13 +1080,20 @@ function devConfig(root, remoteAi) {
   const copy = join(base, '.wrangler', 'homie-dev.wrangler.json');
   mkdirSync(dirname(copy), { recursive: true });
   writeFileSync(copy, `${JSON.stringify(json, null, 2)}\n`);
-  return { args: ['--config', copy, '--persist-to', join(base, '.wrangler', 'state')], note: remoteAi ? 'AI guides think with Workers AI (remote, billed to the signed-in account).' : 'AI guides think scripted here (no Workers AI under dev; --remote-ai for the real one).' };
+  return { args: ['--config', copy, '--persist-to', join(base, '.wrangler', 'state')], note: remoteAi ? 'AI guides think with Workers AI (remote, billed to the signed-in account).' : 'No Workers AI under dev (--remote-ai for the real one, billed): AI guides think with Clef on this computer when Ollama has it, else scripted.' };
 }
 
 /** `agents sit`: an AI guide's seat from this terminal, for a demo or a test of a vocabulary. Lines on stdin act. */
-async function agentsSit(root, game, { url, server, pass, label }) {
+async function agentsSit(root, game, { url, server, pass, label, brain }) {
   const site = url ?? siteUrl(root);
-  const seat = new AgentSeat({ site, game, server: server ?? null, pass: pass ?? null, label: label ?? 'Claude', root });
+  // --brain local: Clef on this computer decides (lib/local-ai.mjs); never a download, only what one would cost.
+  let local = null;
+  if (brain === 'local') {
+    local = await detectLocalAi();
+    if (!local.ok) return { ok: false, command: 'agents sit', why: local.say };
+    log(`This seat thinks with ${local.model} on this computer (Ollama ${local.version}) every few seconds. Type stand to leave.`);
+  } else if (brain !== undefined) return { ok: false, command: 'agents sit', why: '--brain is local (Clef on this computer), or leave it out to choose yourself' };
+  const seat = new AgentSeat({ site, game, server: server ?? null, pass: pass ?? null, label: label ?? (local ? 'Clef' : 'Claude'), root, brain: local ? 'local' : null, local });
   const r = await seat.sit();
   if (!r.ok) return { ok: false, command: 'agents sit', why: r.why };
   log(`Seated as ${r.name} in ${r.room} (seat ${r.seat}). Type: look | do <goal> {"arg":…} | say <line> {"arg":…} with a goal | stand`);

package/chat/CHAT.md

@@ -14,9 +14,12 @@ studio's owner is responsible for, read [OWNERS.md](OWNERS.md).
 
 - **The Chat pill** on the play page, beside the room button: the room's last minutes, the
   reactions, the quick lines, typing where allowed, Report on a line, and two switches ("Show my
-  messages over my character", "Show chat on this screen").
+  messages over my character", "Show chat on this screen"). On a phone it is a round icon, as the
+  room button is, with the count of new lines on its corner; on a computer it says "Chat" unless
+  the word would reach the middle of the top edge, where games keep a clock or a title.
 - **The float:** every reaction rises up every screen in the room.
-- **The ticker:** a new line shows for a moment where the play page's status chip sits.
+- **The strip:** a new line shows for a moment where the play page's status chip sits (the bottom
+  left), or where the game says (below).
 - **The big screen** (`/<game>/tv`) shows the room's lines in a corner; the **watch page** has a
   Chat button; **homie.rocks** shows the room's chat on its card when the studio allows it.
 
@@ -49,9 +52,37 @@ studio's owner is responsible for, read [OWNERS.md](OWNERS.md).
 | `block`, `allow` | the studio's own words to hold (`word*` inside words) or to let through | none |
 
 `"chat": false` turns it off. A kids server, and every beginner server, keeps chat to emoji and
-quick lines whatever the game says. Where new lines show for a moment: game.json
-`"screen": { "chat": "bottom-right" }` (any corner, `top-center` or `bottom-center`), or `false`
-for only the pill's count.
+quick lines whatever the game says.
+
+**Where it sits on the screen, in game.json `"screen"`**, so a game with a busy HUD keeps typed
+chat without anything covering its clock, its title or its controls. The Chat pill sits in the
+room button's band, so `"screen": { "share": … }` places both (`"label": false` keeps both round
+icons). `"screen": { "chat": … }` places the strip of new lines and the big screen's corner:
+
+```json
+"screen": {
+  "share": { "phone": { "at": "top-left", "label": false } },
+  "chat": {
+    "desk": { "at": "top-left", "y": 130 },
+    "phone": { "lines": "sheet-only" },
+    "tv": { "at": "top-right" }
+  }
+}
+```
+
+| Field | | Default |
+|---|---|---|
+| `at` | `top-left`, `top-center`, `top-right`, `bottom-left`, `bottom-center` or `bottom-right` | the bottom left (the bottom right when the room button is at the bottom left) |
+| `x`, `y` | move it in from its side and its edge, in CSS pixels (0 to 600; in the middle of an edge, `x` moves it either way). Sharing the room button's place, it also sits past the button | 0 |
+| `lines` | `strip` (new lines show for a moment), or `sheet-only` (they wait in the Chat sheet and the pill counts them) | `strip` |
+| `desk`, `phone`, `sideways`, `tv` | a computer, a phone held upright, a phone turned sideways (else as `phone`), the big screen: each changes only what it names | |
+
+A plain string (`"chat": "bottom-right"`) is a place for every device, and `false` is
+`"lines": "sheet-only"` for every device. The big screen has no sheet: it takes a corner only
+(the top level's when that is a corner, else the one its join card leaves free) and keeps its
+lines unless its own `tv` entry says `"sheet-only"`, which leaves it the float. A wrong field is
+the default on the page, and `homie-studio build` says which. Look at the play page on a phone
+and a computer while a round is on and somebody says something, and at `/<id>/tv`.
 
 **Speech bubbles over characters**, with the port kit (the starters draw them):
 
@@ -90,6 +121,8 @@ accuracy numbers for it, and the message it reads is a player's, so a player can
 (less of a risk than with a model that writes, since it only scores fixed answers). That is why
 **the word list always runs first and decides alone** whenever the review cannot (no binding, the
 day's budget used, an error, a slow answer). `HOMIE_CHAT_MODEL` switches to Clef or Llama Guard.
+Under `homie-studio dev` with no Workers AI binding, the same question goes to Clef on the person's
+own computer when Ollama has `clef-flash` (0.24.4): free, nothing sent to Cloudflare.
 Firewall for AI (now "AI Security for Apps") was ruled out: it reads HTTP requests at the zone, not
 messages inside a Durable Object, and its detections are an Enterprise add-on.
 

package/lib/agent-seat.mjs

@@ -8,8 +8,13 @@
  *
  * The pass: one the owner gave (`hap_…`), or, from a studio folder, a one-day guide pass minted with the owner's office
  * key and revoked when the AI stands. The secret stays in this process; it is never printed or returned.
+ *
+ * BRAIN 'local' (0.24.4): instead of an AI's turns, Cloudflare's Clef decision model on this computer (Ollama with
+ * clef-flash, lib/local-ai.mjs) decides every few seconds, the way a house guide does (worker/agents.mjs think: the same
+ * questions, the same fixed rules), for free and with nothing sent to Cloudflare. agent_do still overrides it.
  */
-import { parseDecision, renderLine, vocabularyOf } from '../worker/brain.mjs';
+import { clefDecide, parseDecision, renderLine, vocabularyOf } from '../worker/brain.mjs';
+import { think } from '../worker/agents.mjs';
 import { withKey } from './office.mjs';
 
 const GAME = /^[a-z0-9][a-z0-9-]{0,39}$/;
@@ -26,7 +31,7 @@ export class AgentSeat {
    * @param {string} [o.pass]   an agent pass (hap_…); else one is minted from `root` with the office key
    * @param {string} [o.root]   the studio folder (for a pass of its own)
    */
-  constructor({ site, game, server = null, pass = null, label = 'Claude', root = null, WebSocketImpl = globalThis.WebSocket, fetchImpl = globalThis.fetch }) {
+  constructor({ site, game, server = null, pass = null, label = 'Claude', root = null, WebSocketImpl = globalThis.WebSocket, fetchImpl = globalThis.fetch, brain = null, local = null }) {
     this.site = String(site ?? '').replace(/\/+$/, '');
     this.game = game;
     this.server = server;
@@ -52,6 +57,10 @@ export class AgentSeat {
     this.errors = [];
     this.vocab = null;
     this.ping = null;
+    /** brain 'local': Clef on this computer ({ base, model }) decides; its last decisions, and who said no thanks. */
+    this.brain = brain === 'local' && local ? 'local' : null;
+    this.local = local;
+    this.auto = { timer: null, busy: false, at: 0, decisions: [], avoid: new Map(), said: [], goalState: null };
   }
 
   async sit() {
@@ -101,9 +110,56 @@ export class AgentSeat {
     this.ping = setInterval(() => { try { ws.send(JSON.stringify({ t: 'ping', c: Date.now() })); } catch { /* closed */ } }, 2000);
     // The host shows a guide the game every 2 s: wait for the first look (up to 6 s).
     for (let i = 0; i < 30 && !this.view && !this.closed; i += 1) await wait(200);
+    if (this.brain === 'local') this.autopilot();
     return { ok: true, seat: this.seat, name: this.name, room: this.room, server: this.server, ...this.look() };
   }
 
+  /**
+   * BRAIN 'local': a decision on a new ask (at once), when the goal in force ends, else every 12 s while the room has a
+   * view; never more than one at a time, and do() keeps the 3 s pace and the 8 s quiet. No thanks holds that player off
+   * for 10 minutes.
+   */
+  autopilot() {
+    const tick = async () => {
+      if (this.closed) { this.stopAuto(); return; }
+      const now = Date.now();
+      const a = this.auto;
+      const asks = this.asks.filter((x) => now - x.at < 30_000);
+      const state = this.view?.goal && typeof this.view.goal === 'object' ? this.view.goal.state ?? null : null;
+      const ended = (state === 'done' || state === 'failed') && a.goalState !== state;
+      a.goalState = state;
+      if (a.busy || !this.view || !(asks.length || ended || now - a.at >= 12_000)) return;
+      a.busy = true;
+      a.at = now;
+      for (const [s, until] of a.avoid) if (until <= now) a.avoid.delete(s);
+      for (const x of asks) if (this.vocab?.asks?.[x.k]?.leave) a.avoid.set(x.from, now + 10 * 60_000);
+      try {
+        const party = Array.isArray(this.view.party) ? this.view.party.map((p) => p?.seat).filter(Number.isInteger) : [];
+        const ctx = {
+          view: this.view, me: { seat: this.seat }, goal: this.view.goal ?? null, asks, party: this.party.filter((p) => now - p.at < 60_000),
+          speech: this.policy?.speech ?? 'lines', kids: this.policy?.kids === true, quiet: !this.talking() || now - this.sayAt < 8000,
+          players: party, avoid: [...a.avoid.keys()], said: a.said.map((x) => ({ ...x, ago: now - x.at })),
+        };
+        const local = this.local;
+        const t = await think(this.vocab, { mode: 'local', brain: { engine: 'local', run: (args) => clefDecide({}, { vocab: args.vocab, ctx: args.ctx, model: local.model, ms: 8000, local, fetch: this.fetch }) }, ctx });
+        const d = t.decision;
+        let sent = null;
+        if (d?.goal && !this.closed) {
+          const say = d.say && this.talking() && Date.now() - this.sayAt >= 8000 ? d.say : null;
+          sent = await this.do({ goal: d.goal, args: d.args, say, sayArgs: say ? d.sayArgs : {} });
+          if (sent.ok && say) a.said = [...a.said, { line: say, args: d.sayArgs, at: Date.now() }].slice(-4);
+        }
+        a.decisions = [...a.decisions, { at: new Date(now).toISOString(), provider: t.provider, goal: d?.goal ?? null, args: d?.args ?? null, say: d?.say ?? null, ms: t.ms, ...(t.why ? { why: t.why } : {}), ...(sent && !sent.ok ? { refused: sent.why } : {}) }].slice(-20);
+      } catch (error) {
+        a.decisions = [...a.decisions, { at: new Date(now).toISOString(), provider: 'none', why: String(error?.message ?? error).slice(0, 120) }].slice(-20);
+      } finally { a.busy = false; }
+    };
+    this.auto.timer = setInterval(() => { void tick(); }, 1000);
+    void tick();
+  }
+
+  stopAuto() { if (this.auto.timer) clearInterval(this.auto.timer); this.auto.timer = null; }
+
   onFrame(m) {
     switch (m.t) {
       case 'welcome': this.seat = m.seat; this.name = m.name; this.policy = m.policy ?? null; return;
@@ -135,6 +191,7 @@ export class AgentSeat {
       asks: this.asks.filter((a) => now - a.at < 60_000).map((a) => ({ ask: a.k, args: a.args, seat: a.from, text: v ? renderLine(v, a.k, a.args, { kind: 'asks', nameOf: (s) => `seat ${s}` }) : null, secondsAgo: Math.round((now - a.at) / 1000) })),
       party: this.party.filter((p) => now - p.at < 60_000).map((p) => ({ seat: p.seat, line: p.line, args: p.args })),
       lastDo: this.lastDo,
+      ...(this.brain === 'local' ? { brain: { local: this.local.model, decisions: this.auto.decisions.slice(-5) } } : {}),
       choices: v ? { goals: describe(v.goals), lines: describe(v.lines) } : null,
       errors: this.errors.slice(-3),
     };
@@ -162,6 +219,7 @@ export class AgentSeat {
   talking() { return Boolean(this.policy && ['workers-ai', 'owner-key'].includes(this.policy.brain) && this.policy.speech !== 'off'); }
 
   close() {
+    this.stopAuto();
     if (this.ping) clearInterval(this.ping);
     this.ping = null;
     if (this.ws) { try { this.ws.send(JSON.stringify({ t: 'bye' })); } catch { /* closed */ } try { this.ws.close(1000, 'bye'); } catch { /* closed */ } }

package/lib/brain-probe.mjs

@@ -6,14 +6,14 @@
  * doctor asks once.
  *
  * The check is ONE tiny call to the model through Cloudflare's REST API (`POST /accounts/:id/ai/run/:model`, a
- * one-word prompt, max_tokens 1: about 0.1 of the 10,000 free neurons a day), with the studio's own Wrangler login
+ * one-word prompt, max_tokens 1, or for a Clef decision model one yes/no question: a few of the 10,000 free neurons a day), with the studio's own Wrangler login
  * (`wrangler auth token`, held in this process only) or CLOUDFLARE_API_TOKEN. It never prints the token, the account's
  * id or its name. A call that cannot be made (not signed in, several accounts and none named) says so and spends
  * nothing.
  */
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { DEFAULT_MODEL } from '../worker/brain.mjs';
+import { CLEF, DEFAULT_MODEL } from '../worker/brain.mjs';
 import { configPath, workerDir } from './studio.mjs';
 
 const MODELS = 'https://developers.cloudflare.com/workers-ai/models/';
@@ -96,7 +96,8 @@ export async function probeModel({ model, accountId, headers, fetchFn = globalTh
     const res = await fetchFn(`${String(base).replace(/\/+$/, '')}/accounts/${encodeURIComponent(accountId)}/ai/run/${model}`, {
       method: 'POST',
       headers: { ...headers, 'content-type': 'application/json', accept: 'application/json', 'user-agent': 'homie-studio-doctor' },
-      body: JSON.stringify({ messages: [{ role: 'user', content: 'Say OK.' }], max_tokens: 1 }),
+      // A decision model (Clef) takes a state and a question, not a chat message: one yes/no, a few hundred tokens.
+      body: JSON.stringify(CLEF.models[model] ? { model: CLEF.models[model], state: 'OK', questions: { ok: { type: 'noul', instructions: 'Does the state say OK?' } } } : { messages: [{ role: 'user', content: 'Say OK.' }], max_tokens: 1 }),
       signal: AbortSignal.timeout(ms),
     });
     return { status: res.status, body: await res.json().catch(() => null) };
@@ -122,7 +123,7 @@ export async function workersAiRow({ root, studio, env = process.env, exec, fetc
   const where = set ? 'HOMIE_BRAIN_MODEL in wrangler.jsonc' : 'the toolkit\'s default';
   const pick = (lead) => ({
     who: 'ai', open: MODELS,
-    say: `${lead}Pick a model the account can run: set HOMIE_BRAIN_MODEL in wrangler.jsonc "vars" to a text-generation model from ${MODELS} that is not marked Workers Paid${set && model !== DEFAULT_MODEL ? ` (or remove it for the default, ${DEFAULT_MODEL})` : ''}, run \`${cli} doctor\` again, then \`npm run deploy\`. Until then the guides answer from the game's script.`,
+    say: `${lead}Pick a model the account can run: set HOMIE_BRAIN_MODEL in wrangler.jsonc "vars" to a model from ${MODELS} that is not marked Workers Paid (Clef, @cf/cloudflare/clef-flash, or a text-generation model)${set && model !== DEFAULT_MODEL ? ` (or remove it for the default, ${DEFAULT_MODEL})` : ''}, run \`${cli} doctor\` again, then \`npm run deploy\`. Until then the guides answer from the game's script.`,
   });
   const money = ' Moving the account to Workers Paid ($5 a month) also works, but that is the person\'s money: ask them, never decide it.';
   if (!MODEL_ID.test(model)) return { ...row, state: 'act', detail: `${where} is "${model.slice(0, 80)}", which is not a Workers AI model id (@cf/<maker>/<model>)`, fix: pick('') };
@@ -145,7 +146,7 @@ export async function workersAiRow({ root, studio, env = process.env, exec, fetc
     case 'missing': return { ...row, state: 'act', detail: `Cloudflare has no model ${model} (renamed or retired)${said}`, fix: pick('') };
     case 'not-allowed': return { ...row, state: 'act', detail: `this account may not use ${model} (a private model)${said}`, fix: pick('') };
     case 'agreement': return { ...row, state: 'act', detail: `${model} asks for its maker's licence to be agreed once before it is used${said}`, fix: pick('Agreeing to a licence is the person\'s to do, never yours; or simply: ') };
-    case 'input': return { ...row, state: 'act', detail: `${model} did not take a chat message: the guides need a text-generation model${said}`, fix: pick('') };
+    case 'input': return { ...row, state: 'act', detail: `${model} did not take a chat message: the guides need Clef or a text-generation model${said}`, fix: pick('') };
     case 'allowance': return { ...row, state: 'later', detail: `today's free Workers AI allowance (10,000 neurons for the account) is used up, so ${model} could not be checked; the guides answer from the script until 00:00 UTC`, fix: { who: 'person', say: `Nothing to do now: run doctor again after 00:00 UTC. The studio's daily budget (\`${cli} agents brain <game> <server> workers-ai --budget <neurons>\`) keeps the guides under the allowance.` } };
     case 'busy': return { ...row, state: 'unknown', detail: `Workers AI was busy just now (status ${answer.status})${said}; run doctor again in a minute`, fix: null };
     case 'auth': return { ...row, state: 'unknown', detail: `Cloudflare did not let this sign-in run Workers AI (status ${answer.status})${said}`, fix: { who: 'ai', run: 'npx wrangler login', say: 'Sign in to Cloudflare again (the login includes Workers AI), then run doctor again.' } };

package/lib/build.mjs

@@ -47,6 +47,7 @@ import { STUDIO_VERSION } from './version.mjs';
 import { licenseOf, remixRow } from '../worker/license.mjs';
 import { SERVER_LIMITS, serverOf } from '../worker/servers.mjs';
 import { chatProblems } from '../worker/chat.mjs';
+import { screenChatProblems } from '../worker/chat-page.mjs';
 import { vocabularyOf } from '../worker/brain.mjs';
 import { shopForBuild } from './shop.mjs';
 import { audienceOf } from '../worker/shop-rules.mjs';
@@ -321,6 +322,10 @@ export async function build(root, { only = null, log = () => {}, deploy = proces
     // Room chat (NETPLAY.md section 19): game.json "chat", checked here (its quick lines pass the chat floor too).
     const chatBad = chatProblems(g.chat);
     if (chatBad.length) throw new Error(`games/${g.id}/game.json: ${chatBad.join('; ')}`);
+    // A game's own decisions (NETPLAY.md section 20): game.json "decide" is true or false (the Worker answers net.decide only then).
+    if (g.decide !== undefined && typeof g.decide !== 'boolean') throw new Error(`games/${g.id}/game.json: "decide" is true (the host may ask the studio's decision model, within the AI brains' day) or false`);
+    // Where chat sits on the screen (game.json "screen": { "chat" }, 0.24.5): a wrong field is the default on the page.
+    for (const p of screenChatProblems(g.screen?.chat)) log(`warning: games/${g.id}/game.json: ${p}; the play page uses the default there`);
     // The game's own source, for other studios to remix (game.json "share": { "source": false } keeps it private).
     if (g.share?.source !== false) writeFileSync(join(out, 'source.json'), `${JSON.stringify(sourceOf(g.dir, g.id, { studio: studio.name ?? null, game: g.name ?? g.id, license: g.license }))}\n`);
     // Its assets' licences, and the address and SHA-256 of each one a remix may carry (`game remix` fetches them).
@@ -368,6 +373,7 @@ export async function build(root, { only = null, log = () => {}, deploy = proces
       // game.json `"chat"` (0.23.0, NETPLAY.md section 19): the room chat's defaults for this game (the owner's office
       // overrides them), or false for none.
       ...(g.chat === false ? { chat: false } : g.chat && typeof g.chat === 'object' ? { chat: g.chat } : {}),
+      ...(g.decide === true ? { decide: true } : {}),
       // Servers (0.16.0): the seeds game.json ships, the netplay revision its build speaks (the office warns when it
       // predates servers), and game.json "agents": { "vote": "game" | false } (the game draws its own vote card, or none).
       ...(seeds.length ? { servers: seeds } : {}),

package/lib/cloudflare.mjs

@@ -282,6 +282,8 @@ export function needsWorkersAi(root, w, db) {
     // Room chat (0.23.0): a game whose players may type has its messages reviewed by the studio's own Workers AI
     // (Cloudflare's Clef decision model, within a day's budget of the free allocation) unless its game.json says no.
     if ((cat.games ?? []).some((g) => g.chat !== false && (g.chat?.mode ?? 'text') === 'text' && g.chat?.ai !== false)) return true;
+    // A game's own decisions (0.24.4): a game whose game.json says "decide": true asks the same decision model.
+    if ((cat.games ?? []).some((g) => g.decide === true)) return true;
   } catch { /* not built */ }
   const r = w(['d1', 'execute', db, '--remote', '--json', '--command', "SELECT COUNT(*) AS n FROM servers WHERE brain = 'workers-ai' AND state = 'open'"]);
   if (r.code !== 0) return false;

package/lib/doctor.mjs

@@ -19,6 +19,7 @@
  *   Stripe             for selling only in a studio with shop.json (0.24.3): Stripe's own agent plugin (its MCP server
  *                                  and skills) for this AI, set up when the studio starts selling; the shop's key itself
  *                                  goes in through `homie-studio shop connect`, never here
+ *   Clef locally       optional    Ollama with clef-flash: AI under dev for free (never downloaded without a yes)
  *   status line        optional    (Claude Code only) the build's progress under the prompt
  *
  * It is safe at any time, inside a studio or before one exists: it only reads (local files, `--version` of a few
@@ -31,6 +32,7 @@ import { spawn } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { workersAiRow } from './brain-probe.mjs';
+import { detectLocalAi } from './local-ai.mjs';
 import { findChrome } from './chrome.mjs';
 import { whyFailed } from './net.mjs';
 import { isOurs } from './statusline.mjs';
@@ -228,6 +230,18 @@ export async function setupStatus({
     });
   }
 
+  // Clef on this computer (0.24.4, lib/local-ai.mjs): Ollama with clef-flash. Optional, and never downloaded here: the
+  // person says yes to the size first. In a studio only (it serves `dev`).
+  if (root) {
+    const found = await detectLocalAi({ env, fetchFn });
+    rows.push({
+      id: 'local-ai', label: 'Clef on this computer', need: 'optional', state: found.ok ? 'ok' : 'optional',
+      detail: found.ok ? `${found.model} on Ollama ${found.version}` : found.why === 'no-model' ? `Ollama ${found.version} is here, without clef-flash` : found.why === 'old-ollama' ? `Ollama ${found.version} is too old for Clef (0.35.1 or later)` : 'no Ollama running here',
+      unlocks: 'AI guides, chat review and a game\'s own decisions under `dev` with no Cloudflare and no cost, and a guide seat that thinks on this computer (agents sit --brain local)',
+      fix: found.ok ? null : { who: 'person', say: found.say, ...(found.why === 'no-ollama' ? { open: 'https://ollama.com/download' } : {}) },
+    });
+  }
+
   // GitHub.
   rows.push({
     id: 'github', label: 'GitHub', need: 'optional', state: gh.signedIn || gh.onGitHub ? 'ok' : 'optional',