@homie-rocks/studio 0.24.3 → 0.24.5

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

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

package/worker/agents.mjs

@@ -16,7 +16,7 @@
  * Nothing here imports the rest of the Worker (only brain.mjs, which is pure), so the relay (room.mjs) can use the
  * dial and the names as they are.
  */
-import { GUIDE_RULES, costOf, decisionSchema, ownerKey, parseDecision, promptFor, scripted, talks, workersAi } from './brain.mjs';
+import { GUIDE_RULES, costOf, decisionSchema, localAiOf, localClef, ownerKey, parseDecision, promptFor, scripted, talks, workersAi } from './brain.mjs';
 
 /** The skill dial (DESIGN D8; NETPLAY.md section 17). Level 3, Fair, is what the port kit's bots always were. */
 export const SKILLS = Object.freeze([
@@ -271,6 +271,78 @@ export const BRAIN_BUDGET = Object.freeze({ neurons: 8000, usd: 1 });
 export const HOUSE_PASS = 'house-';
 const LOG_MAX = 50;
 
+/**
+ * The brain a server asked for, if it can run now (`{ run, engine }`), or why not (`{ why }`): its Workers AI binding
+ * or the owner's key is there and today's budget is not spent. With neither (`homie-studio dev`, or a key not set yet),
+ * the person's own Ollama runs it when dev found clef-flash there (`engine: 'local'`, free). `providers` stand in for
+ * the network in tests.
+ */
+export function brainFor(mode, env, { budget = null, providers = {} } = {}) {
+  const left = (k) => (budget ? budget.left(k) : Infinity);
+  const p = { 'workers-ai': workersAi, 'owner-key': ownerKey, local: localClef, ...providers };
+  const local = () => (localAiOf(env) ? { run: (args) => p.local(env, args), engine: 'local' } : null);
+  if (mode === 'workers-ai') {
+    if (!env?.AI) return local() ?? { why: 'no Workers AI binding (deploy once more to add it)' };
+    if (left('neurons') <= 0) return { why: 'today\'s Workers AI budget is spent (scripted until 00:00 UTC)' };
+    return { run: (args) => p['workers-ai'](env, args), engine: 'workers-ai' };
+  }
+  if (mode === 'owner-key') {
+    if (!env?.HOMIE_BRAIN_KEY) return local() ?? { why: 'no key yet (homie-studio agents brain key)' };
+    if (left('micros') <= 0) return { why: 'today\'s dollar cap is reached (scripted until 00:00 UTC)' };
+    return { run: (args) => p['owner-key'](env, args), engine: 'owner-key' };
+  }
+  return { why: 'scripted' };
+}
+
+/**
+ * ONE DECISION, the way every brain makes it (the house guides on their alarm, the office's `agents try`): the brain
+ * asked (Clef's questions or a chat model's prompt), its answer checked by parseDecision, the fixed rule applied (a
+ * person's ask is answered the way agents.json says; a model that chose another goal is overruled), and the floor when
+ * nothing else decided.
+ *
+ * ctx: { view, me, goal, asks, party, speech, quiet, players, avoid, kids }. Returns { decision, provider, why, ms,
+ * cost, own (the brain's own pick, before any rule), p (Clef's probabilities), engine, model }.
+ */
+export async function think(vocab, { mode, brain, ctx, ms = BRAIN_CADENCE.timeoutMs, now = Date.now }) {
+  const { asks = [], view = null, players = null, avoid = [], quiet = false } = ctx;
+  const out = { decision: null, provider: 'script', why: brain?.why ?? null, ms: 0, cost: { neurons: 0, micros: 0 }, own: null, p: null, answers: null, usage: null, engine: null, model: null };
+  if (brain?.run) {
+    const t0 = now();
+    const prompt = promptFor(vocab, ctx);
+    const label = brain.engine === 'local' ? 'local' : mode;
+    try {
+      const r = await brain.run({ ...prompt, schema: decisionSchema(vocab), ms, vocab, ctx });
+      out.ms = now() - t0;
+      out.engine = r.engine ?? brain.engine ?? mode;
+      out.model = r.model ?? null;
+      out.p = r.p ?? null;
+      out.answers = r.answers ?? null;
+      out.usage = r.usage ?? null;
+      out.cost = costOf({ provider: out.engine === 'local' ? 'local' : mode, model: r.model, usage: r.usage, system: r.jsonMode === 'clef' ? '' : prompt.system, user: r.jsonMode === 'clef' ? '' : prompt.user, text: typeof r.out === 'string' ? r.out : JSON.stringify(r.out ?? '') });
+      out.cost.provider = label;
+      const parsed = r.out === null || r.out === undefined ? { ok: false, why: r.why ?? 'no answer' } : parseDecision(r.out, vocab, { view, players, avoid });
+      if (parsed.ok) { out.decision = parsed.decision; out.own = parsed.decision; out.provider = label; out.why = null; } else out.why = parsed.why;
+      // A fixed rule: a person's ask is answered the way agents.json says (its goal, with the values the person asked
+      // for). A model that chose another goal, or the asked goal with another value ("Help me with King Slime" answered
+      // with a slime hunt), is overruled by the floor's answer.
+      const ask = asks.at(-1);
+      const want = ask ? vocab.asks[ask.k]?.goal : undefined;
+      const other = out.decision && want && out.decision.goal === want
+        ? Object.entries(ask.args ?? {}).find(([k, v]) => vocab.goals[want].args[k] && vocab.goals[want].args[k].kind !== 'player' && out.decision.args?.[k] !== v) : null;
+      if (out.decision && want && (out.decision.goal !== want || other)) {
+        const floor = scripted(vocab, { asks, view, players, avoid, quiet });
+        if (floor?.goal) { out.why = other ? `the model chose ${want} with ${other[0]} ${String(out.decision.args?.[other[0]]).slice(0, 24)}; the ask was answered as agents.json says` : `the model chose ${out.decision.goal}; the ask was answered as agents.json says`; out.decision = { ...floor, say: floor.say ?? null, sayArgs: floor.sayArgs ?? {} }; out.provider = `${label}+floor`; }
+      }
+    } catch (error) {
+      out.ms = now() - t0;
+      out.why = String(error?.message ?? error).slice(0, 120);
+    }
+  }
+  // The floor: no AI, an AI that failed, or an answer that was not a decision.
+  if (!out.decision) { out.decision = scripted(vocab, { asks, view, players, avoid, quiet }); out.provider = out.decision ? 'script' : 'none'; }
+  return out;
+}
+
 export class HouseAgents {
   /**
    * @param {object} o
@@ -286,7 +358,7 @@ export class HouseAgents {
     this.now = now;
     this.setAlarm = setAlarm;
     this.budget = budget ?? { left: () => Infinity, spend: () => {} };
-    this.providers = { 'workers-ai': workersAi, 'owner-key': ownerKey, ...providers };
+    this.providers = { 'workers-ai': workersAi, 'owner-key': ownerKey, local: localClef, ...providers };
     this.log = log;
     this.agents = [];
     this.decisions = [];
@@ -340,7 +412,7 @@ export class HouseAgents {
     const label = names.length > n ? names[n] : `${names[n % names.length]} ${Math.floor(n / names.length) + 1}`;
     const a = {
       n, pass, name: aiName(label), seat: null, closed: false, view: null, viewAt: 0, zone: undefined, danger: undefined, goalState: null,
-      asks: [], answered: new Map(), carry: null, party: [], avoid: new Map(), calls: [], lastCallAt: -Infinity, dueAt: Infinity, dueWhy: null, sayAt: -Infinity, inFlight: false, provider: null,
+      asks: [], answered: new Map(), carry: null, party: [], said: [], seen: new Map(), avoid: new Map(), calls: [], lastCallAt: -Infinity, dueAt: Infinity, dueWhy: null, sayAt: -Infinity, inFlight: false, provider: null,
     };
     a.conn = {
       loopback: true, ip: null, browser: null, via: null, player: null, qa: false, watch: false,
@@ -405,6 +477,8 @@ export class HouseAgents {
       if (before && (JSON.stringify(d.zone ?? null) !== JSON.stringify(a.zone ?? null) || JSON.stringify(d.danger ?? null) !== JSON.stringify(a.danger ?? null))) this.due(a, now, d.danger ? 'danger' : 'zone');
       a.zone = d.zone ?? null;
       a.danger = d.danger ?? null;
+      // Who is new to this guide (first in its view, for 20 s): a reason to greet them once.
+      for (const p of Array.isArray(d.party) ? d.party.slice(0, 16) : []) if (Number.isInteger(p?.seat) && !a.seen.has(p.seat)) a.seen.set(p.seat, now);
       // Asks the game lists in the view (the host's own player's asks reach a guide this way).
       for (const x of Array.isArray(d.asks) ? d.asks.slice(0, 4) : []) if (x && typeof x.k === 'string' && Number.isInteger(x.from)) this.ask(a, { k: x.k, args: x.args ?? {}, from: x.from, at: Number(x.at) || now }, now);
       if (a.dueAt === Infinity && this.near(a)) this.due(a, Math.max(now, (a.lastCallAt === -Infinity ? now : a.lastCallAt + BRAIN_CADENCE.everyMs)), 'every 12 s');
@@ -474,19 +548,9 @@ export class HouseAgents {
     return due.length;
   }
 
-  /** The brain this server asked for, if it can run now: its binding or key is there, and today's budget is not spent. */
+  /** The brain this server asked for, if it can run now (brainFor above). */
   providerFor(mode) {
-    if (mode === 'workers-ai') {
-      if (!this.env?.AI) return { why: 'no Workers AI binding (deploy once more to add it)' };
-      if (this.budget.left('neurons') <= 0) return { why: 'today\'s Workers AI budget is spent (scripted until 00:00 UTC)' };
-      return { run: (args) => this.providers['workers-ai'](this.env, args) };
-    }
-    if (mode === 'owner-key') {
-      if (!this.env?.HOMIE_BRAIN_KEY) return { why: 'no key yet (homie-studio agents brain key)' };
-      if (this.budget.left('micros') <= 0) return { why: 'today\'s dollar cap is reached (scripted until 00:00 UTC)' };
-      return { run: (args) => this.providers['owner-key'](this.env, args) };
-    }
-    return { why: 'scripted' };
+    return brainFor(mode, this.env, { budget: this.budget, providers: this.providers });
   }
 
   async decide(a) {
@@ -513,41 +577,20 @@ export class HouseAgents {
     const mode = this.room.policy.brain;
     const p = this.providerFor(mode);
     this.why = p.why ?? null;
-    let decision = null;
-    let provider = 'script';
-    let why = p.why ?? null;
-    let ms = 0;
-    let cost = { neurons: 0, micros: 0 };
     // Every decision keeps the 3 s pace (the relay takes one goal every 3 s); AI calls also count to 10 a minute.
     a.lastCallAt = now;
-    if (p.run) {
-      const prompt = promptFor(vocab, { view: a.view, me: { seat: a.seat }, goal: a.view?.goal ?? null, asks, party: a.party, speech: this.room.policy.speech, quiet });
-      a.calls = [...a.calls.filter((t) => t > now - 60_000), now];
-      try {
-        const r = await p.run({ ...prompt, schema: decisionSchema(vocab), ms: BRAIN_CADENCE.timeoutMs });
-        ms = this.now() - now;
-        cost = costOf({ provider: mode, model: r.model, usage: r.usage, system: prompt.system, user: prompt.user, text: typeof r.out === 'string' ? r.out : JSON.stringify(r.out ?? '') });
-        this.calls += 1;
-        this.spent.neurons += cost.neurons;
-        this.spent.micros += cost.micros;
-        this.budget.spend({ ...cost, provider: mode });
-        const parsed = parseDecision(r.out, vocab, { view: a.view, players, avoid });
-        if (parsed.ok) { decision = parsed.decision; provider = mode; why = null; } else why = parsed.why;
-        // A fixed rule: a person's ask is answered the way agents.json says (its goal). A model that chose something
-        // else is overruled by the floor's answer; its line stays when it is one of the ask's.
-        const ask = asks.at(-1);
-        const want = ask ? vocab.asks[ask.k]?.goal : undefined;
-        if (decision && want && decision.goal !== want) {
-          const floor = scripted(vocab, { asks, view: a.view, players, avoid, quiet });
-          if (floor?.goal) { why = `the model chose ${decision.goal}; the ask was answered as agents.json says`; decision = { ...floor, say: floor.say ?? null, sayArgs: floor.sayArgs ?? {} }; provider = `${mode}+floor`; }
-        }
-      } catch (error) {
-        ms = this.now() - now;
-        why = String(error?.message ?? error).slice(0, 120);
-      }
+    if (p.run) a.calls = [...a.calls.filter((t) => t > now - 60_000), now];
+    const said = a.said.filter((x) => now - x.at < 5 * 60_000).map((x) => ({ line: x.line, args: x.args, ago: now - x.at }));
+    const newHere = [...a.seen].filter(([seat, at]) => now - at < 20_000 && players.includes(seat)).map(([seat]) => seat);
+    const ctx = { view: a.view, me: { seat: a.seat }, goal: a.view?.goal ?? null, asks, party: a.party, speech: this.room.policy.speech, kids: this.room.policy.kids, quiet, players, avoid, said, newHere };
+    const t = await think(vocab, { mode, brain: p, ctx, ms: BRAIN_CADENCE.timeoutMs, now: this.now });
+    const { decision, provider, why, ms, cost } = t;
+    if (t.engine) {
+      this.calls += 1;
+      this.spent.neurons += cost.neurons;
+      this.spent.micros += cost.micros;
+      this.budget.spend({ neurons: cost.neurons, micros: cost.micros, provider: cost.provider ?? mode });
     }
-    // The floor: no AI, an AI that failed, or an answer that was not a decision.
-    if (!decision) decision = scripted(vocab, { asks, view: a.view, players, avoid, quiet });
     const did = decision ? this.act(a, decision, quiet) : { goal: null, say: null };
     if (asks.length && decision) {
       for (const x of asks) a.answered.set(`${x.k}|${x.from}|${JSON.stringify(x.args ?? {})}`, now + 6000);
@@ -559,6 +602,8 @@ export class HouseAgents {
       at: now, seat: a.seat, guide: a.pass, provider: decision ? provider : 'none', ms, on: dueWhy,
       goal: did.goal, args: did.goal ? decision.args : null, say: did.say, sayArgs: did.say ? decision.sayArgs : null,
       ...(why ? { why } : {}), ...(cost.neurons ? { neurons: Math.round(cost.neurons * 100) / 100 } : {}), ...(cost.micros ? { micros: cost.micros } : {}),
+      // What the brain itself chose when a rule overruled it (ids only), and how sure a decision model was.
+      ...(t.own && /\+floor$/.test(provider) ? { own: { goal: t.own.goal, args: t.own.args } } : {}), ...(t.p ? { p: t.p } : {}), ...(t.model ? { model: t.model } : {}),
     }].slice(-LOG_MAX);
     a.inFlight = false;
     if (this.near(a) && !a.closed) this.due(a, now + BRAIN_CADENCE.everyMs, 'every 12 s');
@@ -576,6 +621,7 @@ export class HouseAgents {
     if (decision.say && !quiet) {
       a.h.onMessage(JSON.stringify({ t: 'ev', k: `say:${decision.say}`, d: { args: decision.sayArgs ?? {} } }));
       a.sayAt = this.now();
+      a.said = [...a.said, { line: decision.say, args: decision.sayArgs ?? {}, at: a.sayAt }].slice(-4);
       out.say = decision.say;
     }
     return out;