@homie-rocks/studio 0.24.3 → 0.24.4

package/CHANGELOG.md

@@ -17,9 +17,36 @@ 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.4] - 2026-10-03
+
+**Plugin 0.25.4** · [#37](https://github.com/homie-rocks/homie/pull/37)
+
+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
 
@@ -314,7 +327,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 +380,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

@@ -90,6 +90,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

@@ -321,6 +321,8 @@ 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`);
     // 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 +370,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',

package/lib/local-ai.mjs

@@ -0,0 +1,66 @@
+/**
+ * THE PERSON'S OWN AI (@homie-rocks/studio 0.24.4): Cloudflare's Clef decision model on this computer, through Ollama.
+ * The same typed questions the studio's Workers AI answers, at /v1/systemone, free and offline:
+ *
+ *   homie-studio dev        finds it and hands it to the local Worker (HOMIE_LOCAL_AI), so AI guides, room chat's review
+ *                           and a game's own decisions (net.decide) need no Cloudflare while building
+ *   agents sit --brain local / the MCP's agent_sit { brain: "local" }
+ *                           a guide's seat that thinks on this computer every few seconds, with no AI turn per decision
+ *   homie-studio doctor     says what is there, and what one sentence gets the rest
+ *
+ * It never downloads a model. `ollama pull clef-flash` is about 11 GB (clef, the 27B, about 18 GB): the person says yes
+ * first, every time (the studio skill asks and names the size). It needs Ollama 0.35.1 or later (the first with Clef).
+ */
+
+export const OLLAMA_BASE = 'http://127.0.0.1:11434';
+export const OLLAMA_MIN = '0.35.1';
+/** The models Homie uses, smallest first, and what each costs the disk (ollama.com/library, 2026-10-02). */
+export const LOCAL_MODELS = Object.freeze([
+  Object.freeze({ name: 'clef-flash', size: 'about 11 GB', params: '9B' }),
+  Object.freeze({ name: 'clef', size: 'about 18 GB', params: '27B' }),
+]);
+
+const newer = (a, b) => {
+  const pa = String(a).split(/[.-]/).map((x) => parseInt(x, 10) || 0);
+  const pb = String(b).split(/[.-]/).map((x) => parseInt(x, 10) || 0);
+  for (let i = 0; i < 3; i += 1) if ((pa[i] ?? 0) !== (pb[i] ?? 0)) return (pa[i] ?? 0) > (pb[i] ?? 0);
+  return true;
+};
+
+/** Only a loopback address: Homie never sends a game's state to another machine's Ollama. */
+export const loopbackBase = (raw) => {
+  const s = String(raw ?? '').trim().replace(/\/+$/, '');
+  return /^http:\/\/(?:127\.0\.0\.1|localhost|\[::1\]):\d{2,5}$/.test(s) ? s : null;
+};
+
+/**
+ * Is Clef on this computer? `{ ok, base, model, version }`, or `{ ok: false, why, say, version?, base }` with why one of
+ * no-ollama, old-ollama, no-model. `HOMIE_OLLAMA` names another loopback port. Two quick local requests, nothing else.
+ */
+export async function detectLocalAi({ env = process.env, fetchFn = globalThis.fetch, ms = 1500 } = {}) {
+  const base = loopbackBase(env.HOMIE_OLLAMA) ?? OLLAMA_BASE;
+  const get = async (path) => {
+    const res = await fetchFn(`${base}${path}`, { signal: AbortSignal.timeout(ms) });
+    if (!res.ok) throw new Error(`${path} answered ${res.status}`);
+    return res.json();
+  };
+  let version = null;
+  try { version = String((await get('/api/version'))?.version ?? ''); } catch {
+    return { ok: false, base, why: 'no-ollama', say: `Ollama is not running on this computer (${base}). With it and clef-flash, AI guides, chat review and game decisions run here for free while building; without it they play from the game's script under dev.` };
+  }
+  if (!newer(version, OLLAMA_MIN)) return { ok: false, base, version, why: 'old-ollama', say: `Ollama ${version} is here; Clef needs ${OLLAMA_MIN} or later. Updating Ollama is the person's to do (its own app updates itself, or ollama.com/download).` };
+  let names = [];
+  try { names = ((await get('/api/tags'))?.models ?? []).map((m) => String(m?.name ?? m?.model ?? '')).filter(Boolean); } catch { names = []; }
+  for (const want of LOCAL_MODELS) {
+    const hit = names.find((n) => n === want.name || n.startsWith(`${want.name}:`));
+    if (hit) return { ok: true, base, version, model: hit };
+  }
+  const flash = LOCAL_MODELS[0];
+  return {
+    ok: false, base, version, why: 'no-model', models: names.length,
+    say: `Ollama ${version} is here without Clef. Downloading it is the person's choice: ask first. \`ollama pull ${flash.name}\` downloads ${flash.size} (the ${flash.params} model; ${LOCAL_MODELS[1].name} is ${LOCAL_MODELS[1].size}). Then run dev again.`,
+  };
+}
+
+/** The Worker variables that hand a found model to `wrangler dev` (`--var` pairs), or none. */
+export const localAiVars = (found) => (found?.ok ? ['--var', `HOMIE_LOCAL_AI:${found.base}`, '--var', `HOMIE_LOCAL_AI_MODEL:${found.model}`] : []);

package/lib/mcp-tools.mjs

@@ -33,6 +33,7 @@ import { STUDIO_VERSION } from './version.mjs';
 import { compareVersions, whatsNew, whatsNewLines } from './changelog.mjs';
 import { pinnedVersion } from './upgrade.mjs';
 import { AgentSeat } from './agent-seat.mjs';
+import { detectLocalAi } from './local-ai.mjs';
 import { LAB_PORT, runningLab } from './lab.mjs';
 import { pictureFor } from './pictures.mjs';
 import { ART_UI, artToolDefs } from './art-tools.mjs';
@@ -1050,17 +1051,24 @@ export function toolDefs(ctx, avail = {}) {
     {
       name: 'agent_sit', title: 'Sit in a game as an AI guide',
       description: 'Take a guide\'s seat in a live room of one of the studio\'s games as an AI ("Claude · AI": always marked AI, never on a humans-only server, only in a room with people in it). The game\'s own bot code moves the body every frame; you choose its goal and, when the server lets its AI talk, one of the game\'s own lines (agents.json; never free text). Returns your seat, what you see (view), the asks players made of you and your choices. Then agent_look and agent_do every 20 to 40 seconds, and agent_stand when done. Uses the site running here (preview_run) or the live site; with no pass, makes a one-day guide pass with the owner\'s office key and revokes it when you stand.',
-      inputSchema: { type: 'object', properties: { game: str('The game\'s id'), server: str('Optional: a server id (default: the pass\'s, else Quick play)'), pass: str('Optional: an agent pass (hap_…) the owner gave; never shown back'), label: str('Optional: the name you play under (default "Claude"; " · AI" is added)'), url: str('Optional: the site (default: this computer\'s preview, else the live site)'), ...STUDIO_ARG }, required: ['game'] },
+      inputSchema: { type: 'object', properties: { game: str('The game\'s id'), server: str('Optional: a server id (default: the pass\'s, else Quick play)'), pass: str('Optional: an agent pass (hap_…) the owner gave; never shown back'), label: str('Optional: the name you play under (default "Claude"; " · AI" is added)'), url: str('Optional: the site (default: this computer\'s preview, else the live site)'), brain: { type: 'string', enum: ['local'], description: 'Optional: "local" lets Cloudflare\'s Clef decision model on this computer (Ollama with clef-flash) choose every few seconds instead of you, free; agent_look shows what it chose and agent_do still overrides it. Never downloads a model: if Ollama has no clef-flash this says what the download costs, and the person decides.' }, ...STUDIO_ARG }, required: ['game'] },
       annotations: { title: 'Sit in a game as an AI guide', readOnlyHint: false, destructiveHint: false, openWorldHint: true },
       run: async (a) => {
         const root = ctx.root(a.studio);
         if (ctx.seat && !ctx.seat.closed) await ctx.seat.stand();
         const site = a.url ? String(a.url) : devOf(root)?.url ?? siteUrl(root);
         if (!site) return fail('the studio is not running here and has no live site: preview_run first, or studio_deploy');
-        const seat = new AgentSeat({ site, game: String(a.game ?? ''), server: a.server ?? null, pass: a.pass ?? null, label: a.label ? String(a.label).slice(0, 16) : 'Claude', root });
+        let local = null;
+        if (a.brain === 'local') {
+          const found = await detectLocalAi();
+          if (!found.ok) return fail(`No local brain: ${found.say}`, { kind: 'agent', ok: false, error: found.why });
+          local = found;
+        }
+        const seat = new AgentSeat({ site, game: String(a.game ?? ''), server: a.server ?? null, pass: a.pass ?? null, label: a.label ? String(a.label).slice(0, 16) : local ? 'Clef' : 'Claude', root, brain: local ? 'local' : null, local });
         const r = await seat.sit();
         if (!r.ok) return fail(`No seat: ${r.why}`, { kind: 'agent', ok: false, error: r.error ?? null });
         ctx.seat = seat;
+        if (local) return ok(`Seated as ${r.name} in ${r.room} (seat ${r.seat}), thinking with ${local.model} on this computer every few seconds (free; nothing sent to Cloudflare). agent_look shows its last decisions; agent_do overrides; agent_stand ends it.`, { kind: 'agent', ...r });
         return ok(`Seated as ${r.name} in ${r.room} (seat ${r.seat}). ${r.talking ? 'This server lets its AI talk: lines from look.choices.lines, at most one every 8 s.' : 'This server\'s AI does not talk: choose goals only (say null).'} Look again with agent_look; act with agent_do { goal, args, say?, sayArgs? }.\n${JSON.stringify({ view: r.view, asks: r.asks, choices: r.choices }, null, 1).slice(0, 6000)}`, { kind: 'agent', ...r });
       },
     },

package/lib/scaffold.mjs

@@ -342,6 +342,13 @@ studio's pinned copy, never a registry lookup of the bare name.
   it only ASKS. The AI never types: it picks a goal and a line id; the relay drops anything else. With no AI, over
   budget, or between decisions, the game's \`decide\` plays. \`agent_sit\` (the local MCP) puts the owner's own
   Claude in a guide's seat.
+- **Clef (0.24.4):** Workers AI's guides think with Cloudflare's decision model \`@cf/cloudflare/clef-flash\` (it
+  picks among the vocabulary's goals, values and lines; it never writes text; about 9 neurons a decision).
+  \`agents try <id> --view <file> [--ask …] [--model …]\` shows what the brain would decide in one moment. Under
+  \`npm run dev\`, Clef on this computer (Ollama with \`clef-flash\`) runs the guides, chat review and game
+  decisions for free when it is here; **never download it without the person's yes** (\`ollama pull clef-flash\` is
+  about 11 GB). A game whose game.json says \`"decide": true\` may ask \`net.decide(state, questions, { floor })\`
+  on the host (\`NETPLAY.md\` section 20): per beat or per turn, never per frame.
 
 ## Selling things (the shop)