openzoo 0.49.0 → 0.49.2

package/lib/grokui.mjs

@@ -12,7 +12,7 @@ import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, statSyn
 import { cpus, homedir } from 'node:os';
 import path from 'node:path';
 import { adaptiveTopK, brain, brainRace, brainStream, tierModels, MODEL, PROXY, TIER_NAMES, normalizeTier } from './podagent.mjs';
-import { peekDirectiveStatus, formatRaceStatus, STALE_THINKING_MS, summarizeRaceFailures } from './livestatus.js';
+import { peekDirectiveStatus, formatRaceStatus, STALE_THINKING_MS, summarizeRaceFailures, RACE_EVERY_FAILED } from './livestatus.js';
 import { creditBalance } from './info.js';
 import {
   SUBSCRIPTIONS_PAGE,
@@ -491,7 +491,7 @@ function newThread(name, parent, members, spec) {
   const p = parent ? threads.get(parent) : null;
   const t = { id, name, color: members ? members[0].color : colorFor(name), parent: parent || null,
     messages: members ? null : [{ role: 'system', content: SYSTEM }],
-    members: members || null, history: [], status: 'idle', createdAt: Date.now(), lastActivityAt: Date.now(),
+    members: members || null, history: [], status: 'idle', turnSeq: 0, createdAt: Date.now(), lastActivityAt: Date.now(),
     ...(p?.runMode ? { runMode: p.runMode } : {}),
     ...(p?.model ? { model: p.model } : {}),
     ...(p?.tier ? { tier: p.tier } : {}),
@@ -687,6 +687,47 @@ const NUDGE = 'That reply announced work instead of doing it — no directive li
 const AUTO_CONTINUE = 'AUTO is still on — do not stop and do not ask the user to type continue. '
   + 'Emit the next directive now (RUN:/SPAWN:/SEND:/READ:/WRITE:/GLOB:/FETCH:/MCP:/SERVE:), '
   + 'or DONE: if the job is actually finished.';
+const AUTO_RACE_RETRY = 'AUTO is still on — the last model call failed (race/empty/error). '
+  + 'Do not stop and do not ask the user to type continue. '
+  + 'Emit the next directive now (RUN:/SPAWN:/SEND:/READ:/WRITE:/GLOB:/FETCH:/MCP:/SERVE:), '
+  + 'or DONE: if the job is actually finished.';
+// Said it would, without a directive line. "Spawned X" and "working on it" are
+// in here because they are FALSE without a SPAWN: in the same reply — the bot
+// reports success for something the harness never saw.
+const ANNOUNCEMENT = /\b(?:I(?:'| a)?ll |I will |let me |I'm going to |I am going to |first,? |next,? |now I'll |starting|kicking off|spawn(?:ing|ed)|about to|going to (?:check|run|create|start|install))\b/i;
+const STALLED_OFFER = /\b(?:if you want(?:ed)?,? I can|should I\b|let me know(?: and I['’]ll)?|ready to proceed|want me to|would you like(?: me to)?|spawned \S[\s\S]{0,80}working on it|kicked that off)\b/i;
+function isDoneReply(text) {
+  return /^[ \t>*-]*DONE:/m.test(String(text || ''));
+}
+function isTransientModelFail(text) {
+  const s = String(text || '').trim();
+  if (s === RACE_EVERY_FAILED || /^\(race:\s*every model failed/i.test(s)) return true;
+  if (/^error:/i.test(s)) return true;
+  if (/returned nothing \d+ times|each returned nothing/i.test(s)) return true;
+  return false;
+}
+function isPaymentFailed(text) {
+  return /\b(?:payment failed|HTTP 402|wallet is empty|empty wallet)\b/i.test(String(text || ''));
+}
+// Park only: ask mode, pendingRun, DONE:, 402/empty-wallet, or the hard cap.
+function shouldKeepAuto(t, reply) {
+  if (!t || t.runMode !== 'auto') return false;
+  if (t.pendingRun) return false;
+  if ((t.autoSteps || 0) >= AUTO_MAX_STEPS) return false;
+  if (isDoneReply(reply)) return false;
+  if (isPaymentFailed(reply)) return false;
+  return true;
+}
+function enqueueAutoHop(t, threadId, userText, onEvent) {
+  bindThread(t).catch(() => {});
+  t.autoSteps = (t.autoSteps || 0) + 1;
+  if (t.autoSteps >= AUTO_MAX_STEPS) return false;
+  kickTurn(threadId, userText, onEvent).catch(() => {});
+  return true;
+}
+function autoHopText(reply) {
+  return isTransientModelFail(reply) ? AUTO_RACE_RETRY : AUTO_CONTINUE;
+}
 // PING used to be a read: last-line status, no turn. Idle children stayed idle
 // while the parent treated the dump as evidence they had acted. A ping is a
 // wake — the same harness continue AUTO already uses, unless a custom message
@@ -695,6 +736,10 @@ let runTurnOverride = null;
 function setRunTurnForTest(fn) {
   runTurnOverride = typeof fn === 'function' ? fn : null;
 }
+let brainAskOverride = null;
+function setBrainAskForTest(fn) {
+  brainAskOverride = typeof fn === 'function' ? fn : null;
+}
 function kickTurn(threadId, userText, onEvent, images) {
   // Default to emitToThread so a spawned/pinged kid streams when someone has
   // that thread open. emitToThread is a no-op if nobody is watching.
@@ -731,14 +776,14 @@ const SPAWN_MAX_CHILDREN = Number(process.env.OZ_SPAWN_MAX_CHILDREN)
 
 // Injected fresh on every AUTO turn, never persisted into the thread.
 //
-// The auto loop only continues while directives keep parsing, so a reply that
-// merely OFFERS ends the run — auto silently degrades to ask the moment the
-// model hedges. Observed live: "If you want, I can rewrite the prompt with
-// these fixes folded in", "Spawned mcp-integration — working on it" with
-// nothing spawned, and a user reduced to answering "no, this... impl all".
-// Models are trained to close on a consent question; in auto that instinct is
-// the bug. The system prompt is frozen into a thread at creation, so an
-// existing thread can only be reached by a per-turn message.
+// The auto loop keeps going until DONE:, a real blocking question, or the
+// step cap. A reply that merely OFFERS used to end the run — auto silently
+// degraded to ask the moment the model hedged. Observed live: "If you want,
+// I can rewrite the prompt", "Spawned mcp-integration — working on it" with
+// nothing spawned, and a kid that RAN ls then sat idle. Models are trained
+// to close on a consent question; in auto that instinct is the bug. The
+// system prompt is frozen into a thread at creation, so an existing thread
+// can only be reached by a per-turn message.
 const AUTO_DIRECTIVE = `AUTO MODE IS ON for this thread.
 
 Do the work in this turn. Do not ask whether to proceed, do not offer to do it,
@@ -756,7 +801,11 @@ Announcing an action does not perform it. "Spawned X", "working on it" and
 If a task needs several commands, emit the FIRST one now; you get its real
 output back and continue from there. Only stop to ask when the next step is
 genuinely destructive and irreversible, or when you truly cannot proceed
-without a fact only the user has.`;
+without a fact only the user has.
+
+When the job is actually finished, emit DONE: as the first line. A status
+sentence is not a stop — the harness keeps this thread working until DONE:,
+a real blocking question, or the step cap.`;
 async function bindThread(t) {
   // Only bind what's NEW since the last successful bind, continuing the
   // existing context_id — previously this rebuilt and re-sent the WHOLE
@@ -1264,6 +1313,7 @@ async function handleSlash(task, t) {
     const crew = subtreeOf(t.id);
     if (!crew.length) return 'You have no subagents to send to.';
     for (const x of crew) kickTurn(x.id, arg).catch(() => {});
+    if (t.runMode === 'auto' && pingCanWake(t)) wakeOnPing(t, arg);
     return `Sent down your branch to ${crew.length} bot(s): ${crew.map((x) => x.name).join(', ')}`;
   }
 
@@ -1277,6 +1327,10 @@ async function handleSlash(task, t) {
     return crew.map((x) => {
       const mark = x.id === t.id ? ' (here)' : '';
       if (x.id === t.id) {
+        if (t.runMode === 'auto' && pingCanWake(t)) {
+          wakeOnPing(t, arg);
+          return `  ${x.name}${mark}: pinged, working`;
+        }
         const last = x.history[x.history.length - 1];
         return x.pendingRun ? `  ${x.name}${mark}: BLOCKED — waiting for your approval`
           : x.status === 'thinking' ? `  ${x.name}${mark}: working`
@@ -1354,9 +1408,15 @@ setInterval(() => {
     if (!last || now - last < STALE_THINKING_MS) continue;
     t.turnSeq = (t.turnSeq || 0) + 1;
     try { turnAborts.get(t)?.abort(); } catch { /* none */ }
-    t.status = 'idle';
-    t.liveStatus = '';
-    unlockWorktree(t);
+    const lastBot = [...(t.history || [])].reverse().find((h) => h.who === 'bot');
+    const lastText = lastBot?.text || '';
+    if (shouldKeepAuto(t, lastText)) {
+      kickTurn(t.id, isTransientModelFail(lastText) ? AUTO_RACE_RETRY : AUTO_CONTINUE).catch(() => {});
+    } else {
+      t.status = 'idle';
+      t.liveStatus = '';
+      unlockWorktree(t);
+    }
     dirty = true;
   }
   if (dirty) saveThreads();
@@ -1615,7 +1675,8 @@ function unwrapDirectiveLine(reply) {
 function isHarnessUserText(text) {
   return /^\((command output|directive result)\)/.test(String(text || ''))
     || String(text || '') === NUDGE
-    || String(text || '') === AUTO_CONTINUE;
+    || String(text || '') === AUTO_CONTINUE
+    || String(text || '') === AUTO_RACE_RETRY;
 }
 
 function firstUserAsk(t) {
@@ -2365,7 +2426,11 @@ async function runTurn(threadId, userText, onEvent, images) {
   // status=thinking and the UI on "…".
   if (!isHarnessUserText(userText)) t.turnSeq = (t.turnSeq || 0) + 1;
   const seq = t.turnSeq || 0;
-  const stillMine = () => threads.get(threadId)?.turnSeq === seq;
+  // Missing turnSeq is 0, not undefined. A ping/AUTO_CONTINUE as the first
+  // message used to make stillMine() always false (undefined === 0), so the
+  // RUN ran or the model was paid and then the hop bailed before chaining —
+  // kids looked "pinged" then dead.
+  const stillMine = () => (threads.get(threadId)?.turnSeq || 0) === seq;
   const paint = (ev) => {
     if (!stillMine()) return;
     if (ev.type === 'status' && ev.detail && t.status === 'thinking') t.liveStatus = ev.detail;
@@ -2386,11 +2451,13 @@ async function runTurn(threadId, userText, onEvent, images) {
   t.liveStatus = (!t.model && raceN >= 2) ? formatRaceStatus(0, raceNeed) : 'waiting on model…';
   let chained = false;
   let parked = false;
+  let lastReply = '';
   try {
   if (t.members) {
     // sequential, not parallel: each member's context is rebuilt from
     // t.history right before its turn, so it sees every reply (including
     // spawns/sends) the earlier members in THIS round already made
+    let memberReply = '';
     for (const m of t.members) {
       if (!stillMine()) return;
       const msgs = buildMemberMessages(t, m);
@@ -2404,6 +2471,7 @@ async function runTurn(threadId, userText, onEvent, images) {
       } catch (e) { r = `error: ${e.message}`; }
       if (!stillMine()) return;
       r = stripThinkTags(r);
+      memberReply = r;
       const runCmd = parseRun(r);
       if (runCmd) {
         const command = runCmd;
@@ -2413,6 +2481,7 @@ async function runTurn(threadId, userText, onEvent, images) {
           const shown = `$ ${command}\n${output}`;
           t.history.push({ who: 'bot', text: shown, name: m.name, color: m.color });
           paint({ type: 'final', name: m.name, color: m.color, text: shown });
+          memberReply = shown;
           // this member's turn is done; the round continues to the next member
           continue;
         }
@@ -2429,8 +2498,13 @@ async function runTurn(threadId, userText, onEvent, images) {
       const finalText = ack ?? (r || '(no response)');
       t.history.push({ who: 'bot', text: finalText, name: m.name, color: m.color });
       paint({ type: 'final', name: m.name, color: m.color, text: finalText });
+      memberReply = r;
     }
     bindThread(t).catch(() => {});
+    lastReply = memberReply;
+    if (shouldKeepAuto(t, memberReply)) {
+      chained = enqueueAutoHop(t, threadId, autoHopText(memberReply), onEvent);
+    }
     return;
   }
   // A real message from the user resets the auto budget AND the announcement
@@ -2469,6 +2543,11 @@ async function runTurn(threadId, userText, onEvent, images) {
   // `attempt` exists because a retry must be allowed to land somewhere else:
   // see the empty-completion loop below.
   const ask = async (attempt = 0) => {
+    if (brainAskOverride) {
+      return String(await brainAskOverride({
+        thread: t, attempt, userText, messages: callMsgs,
+      }) ?? '').trim();
+    }
     const emit = (delta, meta) => paint({
       type: 'delta', name: t.name, color: t.color, delta,
       ...(meta?.replace ? { replace: true } : {}),
@@ -2490,6 +2569,7 @@ async function runTurn(threadId, userText, onEvent, images) {
       return (await brainRace(callMsgs, emit, t.contextId, models, need, undefined, emitStatus, {
         signal: turnAbort.signal,
         onArrivals: (arr) => { t.lastRaceFail = summarizeRaceFailures(arr); },
+        tier: t.tier || 'medium',
       })).trim();
     }
     // A retry draws a DIFFERENT model from the tier rather than the same one.
@@ -2516,7 +2596,7 @@ async function runTurn(threadId, userText, onEvent, images) {
     // sick provider. Empties are per-model and uncorrelated, so moving is the
     // fix. A thread pinned with /model stays pinned; that was an explicit
     // choice and silently answering as something else would be worse.
-    for (let i = 0; !reply && i < AUTO_EMPTY_RETRIES; i++) {
+    for (let i = 0; (!reply || isTransientModelFail(reply)) && i < AUTO_EMPTY_RETRIES; i++) {
       paint({ type: 'status', name: t.name, color: t.color, detail: 'retrying…' });
       await new Promise((r) => setTimeout(r, 400 * (i + 1)));
       if (!stillMine()) return;
@@ -2532,6 +2612,7 @@ async function runTurn(threadId, userText, onEvent, images) {
   }
   if (!stillMine()) return;
   reply = stripThinkTags(reply);
+  lastReply = reply;
   t.messages.push({ role: 'assistant', content: reply });
   const runCmd = parseRun(reply);
   if (runCmd) {
@@ -2551,24 +2632,13 @@ async function runTurn(threadId, userText, onEvent, images) {
       // Bounded, because this is a loop that spends real money on every hop:
       // AUTO_MAX_STEPS chained commands per user message, reset whenever the
       // user speaks again.
-      t.autoSteps = (t.autoSteps || 0) + 1;
-      if (t.autoSteps < AUTO_MAX_STEPS) {
-        // BIND BEFORE CHAINING. bindThread only ran at the end of a normal
-        // turn, and both auto paths return before reaching it — so in auto
-        // mode nothing was ever bound, exactly when the agent produces the
-        // most material (command output, GLOB results, MCP tool lists). The
-        // holographic context stopped growing precisely when it mattered.
-        bindThread(t).catch(() => {});
-        chained = true;
-        runTurn(threadId, condense('(command output)', output), onEvent).catch(() => {});
-      } else {
-        // Do not park. A "say continue" note is the failure mode auto exists
-        // to avoid — inject continue and keep going until DONE or ask.
-        t.autoSteps = 0;
-        bindThread(t).catch(() => {});
-        chained = true;
-        runTurn(threadId, AUTO_CONTINUE, onEvent).catch(() => {});
-      }
+      // BIND BEFORE CHAINING. bindThread only ran at the end of a normal
+      // turn, and both auto paths return before reaching it — so in auto
+      // mode nothing was ever bound, exactly when the agent produces the
+      // most material (command output, GLOB results, MCP tool lists). The
+      // holographic context stopped growing precisely when it mattered.
+      lastReply = shown;
+      chained = enqueueAutoHop(t, threadId, condense('(command output)', output), onEvent);
       return;
     }
     {
@@ -2598,16 +2668,8 @@ async function runTurn(threadId, userText, onEvent, images) {
   // Same budget as RUN (shared t.autoSteps, reset when the user speaks), so
   // this cannot spend more than a chained RUN loop already could.
   if (t.runMode === 'auto' && ack !== null && ack !== undefined
-      && !/^[ \t>*-]*DONE:/m.test(reply)) {
-    t.autoSteps = (t.autoSteps || 0) + 1;
-    bindThread(t).catch(() => {});   // bind every hop, not just the last one
-    chained = true;
-    if (t.autoSteps < AUTO_MAX_STEPS) {
-      runTurn(threadId, condense('(directive result)', ack), onEvent).catch(() => {});
-    } else {
-      t.autoSteps = 0;
-      runTurn(threadId, AUTO_CONTINUE, onEvent).catch(() => {});
-    }
+      && !isDoneReply(reply)) {
+    chained = enqueueAutoHop(t, threadId, condense('(directive result)', ack), onEvent);
     return;
   }
 
@@ -2622,50 +2684,43 @@ async function runTurn(threadId, userText, onEvent, images) {
   // AUTO_DIRECTIVE already forbids this in the prompt, and models do it anyway.
   // A prompt rule with no enforcement is a suggestion. Re-ask once, in-band.
   //
-  // NARROW ON PURPOSE. It fires only on announcement language, never on a plain
-  // answer — auto is also how you hold an ordinary conversation, and nudging a
-  // finished reply would spend a turn arguing with a bot that already
-  // succeeded. Once per turn (autoNudged), so a model that announces twice
-  // still stops instead of looping on the user's wallet.
+  // NUDGE announcements (stronger than a bare continue). Plain replies used
+  // to park here; they now fall through to AUTO_CONTINUE unless DONE: or a
+  // real blocking question. The step cap is the wallet bound.
   if (t.runMode === 'auto' && (ack === null || ack === undefined)
       && (STALLED_OFFER.test(reply) || ANNOUNCEMENT.test(reply))) {
     // Offers and "Spawned X — working on it" with no directive must not end
     // the run. The old once-only autoNudged gate parked the thread after one
-    // hedge and the user typed continue. Keep going; AUTO_MAX_STEPS injects
-    // another continue rather than stopping.
+    // hedge and the user typed continue.
     t.autoNudged = true;
-    t.autoSteps = (t.autoSteps || 0) + 1;
-    bindThread(t).catch(() => {});
-    chained = true;
-    if (t.autoSteps < AUTO_MAX_STEPS) {
-      runTurn(threadId, NUDGE, onEvent).catch(() => {});
-    } else {
-      t.autoSteps = 0;
-      runTurn(threadId, AUTO_CONTINUE, onEvent).catch(() => {});
-    }
+    chained = enqueueAutoHop(t, threadId, NUDGE, onEvent);
+    return;
+  }
+
+  // After any auto reply that is not DONE: and not waiting on approval,
+  // kick immediately. Race/empty/error uses AUTO_RACE_RETRY.
+  if (shouldKeepAuto(t, reply)) {
+    chained = enqueueAutoHop(t, threadId, autoHopText(reply), onEvent);
     return;
   }
   bindThread(t).catch(() => {});
   } finally {
-    // A hung or thrown brainStream used to leave t.status = 'thinking' and the
-    // UI on mute "…" forever. Always idle unless this hop chained or parked
-    // on an approval — the next runTurn sets thinking again itself.
-    if (stillMine() && !chained && !parked && !t.pendingRun) {
-      t.status = 'idle';
-      t.liveStatus = '';
-      unlockWorktree(t);
+    // Idle only when this hop should not keep AUTO going: DONE:, pendingRun,
+    // ask mode, 402/empty-wallet, or the hard cap. Otherwise kick again.
+    if (stillMine() && !chained && !parked) {
+      if (shouldKeepAuto(t, lastReply)) {
+        enqueueAutoHop(t, threadId, autoHopText(lastReply), onEvent);
+      } else if (!t.pendingRun) {
+        t.status = 'idle';
+        t.liveStatus = '';
+        unlockWorktree(t);
+      }
     }
     t.lastActivityAt = Date.now();
     saveThreads();
   }
 }
 
-// Said it would, without a directive line. "Spawned X" and "working on it" are
-// in here because they are FALSE without a SPAWN: in the same reply — the bot
-// reports success for something the harness never saw.
-const ANNOUNCEMENT = /\b(?:I(?:'| a)?ll |I will |let me |I'm going to |I am going to |first,? |next,? |now I'll |starting|kicking off|spawn(?:ing|ed)|about to|going to (?:check|run|create|start|install))\b/i;
-const STALLED_OFFER = /\b(?:if you want(?:ed)?,? I can|should I\b|let me know(?: and I['’]ll)?|ready to proceed|want me to|would you like(?: me to)?|spawned \S[\s\S]{0,80}working on it|kicked that off)\b/i;
-
 /**
  * The PROJECT a thread belongs to = the root of its spawn tree, and how deep
  * it sits. Every thread already carried the parent id; nothing ever walked it, so
@@ -4898,9 +4953,14 @@ const APP_HTML = `<!doctype html>
       const cogs = Number(you.cogsUsd) || 0;
       const direct = Number(you.directUsd) || 0;
       const margin = spent > 0 ? Math.round((spent - cogs) / spent * 100) + '%' : '—';
+      const cogsOver = cogs > spent;
       document.getElementById('hYouSpent').textContent = usd(spent);
-      document.getElementById('hYouCogs').textContent = usd(cogs);
-      document.getElementById('hYouMargin').textContent = margin;
+      const cogsEl = document.getElementById('hYouCogs');
+      cogsEl.textContent = usd(cogs);
+      cogsEl.className = cogsOver ? 'hember' : '';
+      const marginEl = document.getElementById('hYouMargin');
+      marginEl.textContent = margin;
+      marginEl.className = cogsOver ? 'hember' : 'hlime';
       document.getElementById('hYouDirect').textContent = usd(direct);
       const savedEl = document.getElementById('hYouSaved');
       const hintEl = document.getElementById('hHint');
@@ -4913,19 +4973,26 @@ const APP_HTML = `<!doctype html>
         // is shipping the WHOLE corpus), so 2dp would read as noise up there.
         savedEl.textContent = (mult >= 100 ? Math.round(mult) : mult.toFixed(mult >= 10 ? 1 : 2)) + 'x';
         savedEl.className = mult >= 1 ? 'hlime' : 'hember';
-        // Under 1x is real, but on its own it just reads as "this is a bad
-        // deal". It isn't a verdict on the product — it's a verdict on how
-        // little you've given it to work against: you're billed on the tokens
-        // actually forwarded, while "direct" is the cost of shipping the whole
-        // corpus. The forwarded slice grows barely at all as the corpus grows,
-        // so the ratio climbs with corpus size. Say that, and say what to do.
-        hintEl.className = mult >= 1 ? 'hhint' : 'hhint show';
-        hintEl.innerHTML = '<b>feed it more.</b> you\\'re billed on the slice actually sent, '
-          + 'not the corpus — so the more you bind, the further ahead this gets. '
-          + 'small inputs cost more than sending them straight.';
+        // Session direct/spent (never first-call). Cogs-over-paid is the
+        // louder warn — unused grant-back should have kept used cogs ≤ billed.
+        if (cogsOver) {
+          hintEl.className = 'hhint show';
+          hintEl.innerHTML = '<b>cogs above paid.</b> our cost exceeded what you were billed '
+            + '— this line is used racers, not the N+judge ceiling.';
+        } else {
+          hintEl.className = mult >= 1 ? 'hhint' : 'hhint show';
+          hintEl.innerHTML = '<b>feed it more.</b> you\\'re billed on the slice actually sent, '
+            + 'not the corpus — so the more you bind, the further ahead this gets. '
+            + 'small inputs cost more than sending them straight.';
+        }
       } else {
         savedEl.textContent = '—';
-        hintEl.className = 'hhint';
+        if (cogsOver) {
+          hintEl.className = 'hhint show';
+          hintEl.innerHTML = '<b>cogs above paid.</b> our cost exceeded what you were billed.';
+        } else {
+          hintEl.className = 'hhint';
+        }
       }
       document.getElementById('hFoot').textContent = (you.paidCalls || 0) + ' paid calls this session';
     } catch (e) {
@@ -5355,7 +5422,9 @@ server.listen(PORT, BIND, () => console.log(`[grokui] http://${BIND === '0.0.0.0
 export {
   tryDirective, ensureWorkspacePort, isPreviewableRel, previewAck, workspaceFileUrl,
   parseRun, looksLikeMcpAsBash, stripThinkTags, safeResolveIn, inDir, listDir,
-  handleSlash, newThread, setRunTurnForTest, AUTO_CONTINUE, pingWakeText, pingCanWake,
-  childKickoff, findByName, attachChildDir, finishChildDir, lockWorktree, unlockWorktree,
-  parsePrRef, fetchSpecsForOrigin, agentSlug,
+  handleSlash, newThread, setRunTurnForTest, setBrainAskForTest, runTurn,
+  AUTO_CONTINUE, AUTO_RACE_RETRY, pingWakeText, pingCanWake, shouldKeepAuto,
+  isDoneReply, isTransientModelFail, enqueueAutoHop, childKickoff, findByName,
+  attachChildDir, finishChildDir,
+  lockWorktree, unlockWorktree, parsePrRef, fetchSpecsForOrigin, agentSlug,
 };

package/lib/podagent.mjs

@@ -28,12 +28,19 @@ import {
   isRaceCountable, raceLastShip, shouldRetryRaceArrival, raceFailKind,
   summarizeRaceFailures,
 } from './livestatus.js';
+import {
+  probeGatewayRace, capRaceByCredit, inferRaceTier, RACE_NO_CREDIT,
+} from './racesettle.js';
 import { homedir } from 'node:os';
 
 const PORTS = (process.env.OZ_AGENT_PORTS || '1337,6080,1340,6081')
   .split(',').map((s) => Number(s.trim())).filter(Boolean);
 const LOG = process.env.OZ_AGENT_LOG || '/var/log/openzoo/agent.jsonl';
 export const PROXY = process.env.OZ_PROXY || 'http://127.0.0.1:8402/v1';
+/** Live value — tests point OZ_PROXY at a mock after this module loads. */
+function completionsProxy() {
+  return process.env.OZ_PROXY || PROXY;
+}
 export const MODEL = process.env.OZ_BRAIN_MODEL || 'deepseek/deepseek-v4-pro-0813';
 const MAX_STEPS = Number(process.env.OZ_MAX_STEPS || 10);
 
@@ -289,7 +296,7 @@ async function postChat(body, contextId, topK, onStatus, signal) {
       err.name = 'AbortError';
       throw err;
     }
-    r = await fetch(`${PROXY}/chat/completions`, {
+    r = await fetch(`${completionsProxy()}/chat/completions`, {
       method: 'POST',
       headers: {
         'content-type': 'application/json', authorization: 'Bearer sk-openzoo',
@@ -649,6 +656,250 @@ export async function tierModels(tier, n = 1, random = false) {
   return a.slice(0, take);
 }
 
+async function readProxySession(proxy = completionsProxy()) {
+  try {
+    const origin = String(proxy || '').replace(/\/+$/, '').replace(/\/v1$/i, '');
+    const r = await fetch(`${origin}/v1/session`, { signal: AbortSignal.timeout(800) });
+    if (!r.ok) return null;
+    return await r.json();
+  } catch { return null; }
+}
+
+async function raceBudget(hooks) {
+  if (hooks.creditUsd != null || hooks.quoteUsd != null) {
+    return { creditUsd: hooks.creditUsd, quoteUsd: hooks.quoteUsd };
+  }
+  // Injected stream = unit-test N-parallel path. Do not poke :8402.
+  if (hooks.stream) return {};
+  const s = await readProxySession(hooks.proxy || completionsProxy());
+  return {
+    creditUsd: s?.creditUsd,
+    quoteUsd: s?.lastQuoteUsd ?? s?.quoteUsd,
+  };
+}
+
+function raceRacerId(obj, fallback) {
+  const r = obj?.race || obj?.racer || {};
+  if (r.model) return String(r.model);
+  if (r.i != null) return `racer-${r.i}`;
+  if (obj?.model) return String(obj.model);
+  const idx = obj?.choices?.[0]?.index;
+  if (idx != null && idx !== 0) return `racer-${idx}`;
+  return fallback || 'gateway';
+}
+
+function raceEventOf(obj) {
+  const r = obj?.race || obj?.racer;
+  if (!r || typeof r !== 'object') return null;
+  const ev = String(r.event || r.status || '').toLowerCase();
+  return { id: raceRacerId(obj, 'gateway'), ev, text: r.text, error: r.error };
+}
+
+/**
+ * One Fly (or race-capable mock) POST. Streams tokens. First-X-countable:
+ * empties / HTTP / pay / fetch-failed do not fill X.
+ */
+async function brainGatewayRace(messages, onDelta, contextId, models, need, maxTokens, onStatus, hooks) {
+  const n = models.length;
+  const want = Math.max(1, Math.min(Number(need) || 1, n));
+  const tier = hooks.tier || inferRaceTier(models, 'medium');
+  const classify = hooks.classify || classifyRaceAnswer;
+  const pairwise = hooks.pairwise || pairwiseTied;
+  const minScore = hooks.minScore != null ? Number(hooks.minScore) : RACE_MIN_SCORE;
+  const feed = createRaceFeed(onDelta, onStatus, want);
+  feed.start();
+
+  const arrivals = [];
+  const done = [];
+  const noteRace = (arr) => {
+    try {
+      hooks.onArrivals?.(arr);
+      const line = JSON.stringify({
+        at: new Date().toISOString(),
+        fail: summarizeRaceFailures(arr),
+        n: arr.length,
+        kinds: arr.map((a) => raceFailKind(a)),
+        door: 'gateway',
+      });
+      appendFileSync(`${homedir()}/.openzoo/grokui-race.log`, line + '\n');
+    } catch { /* diagnostic only */ }
+  };
+  const ship = (cand) => {
+    const out = cand && String(cand.text || '').trim() ? cand : raceLastShip(arrivals);
+    feed.settle(out);
+    noteRace(arrivals);
+    return out.text;
+  };
+
+  const vision = hasImages(messages);
+  const model = vision ? VISION_MODEL : (models[0] || MODEL);
+  const msgs = vision ? messages : stripImages(messages);
+  const budget = maxTokens || MAX_TOKENS;
+  const body = {
+    model,
+    max_tokens: budget,
+    messages: withModelId(msgs, model),
+    plugins: [{ id: 'web' }],
+    stream: true,
+    race: n,
+    race_need: want,
+    tier,
+  };
+
+  let lastFail = { model: 'gateway', text: '', error: 'empty body' };
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const r = await postChat(body, contextId, 0, onStatus, hooks.signal);
+      if (!r.ok || !r.body) {
+        const j = await r.json().catch(() => ({}));
+        const content = j?.choices?.[0]?.message?.content;
+        const proxied = j?.error?.message;
+        const text = content || (r.ok ? '' : (proxied ? `(request failed — HTTP ${r.status}: ${proxied})` : await httpErrorNote(r.status)));
+        lastFail = { model: 'gateway', text: text || '', error: r.ok ? undefined : `HTTP ${r.status}` };
+        if (isRaceCountable(lastFail)) {
+          arrivals.push(lastFail);
+          done.push(lastFail);
+          feed.onBack();
+          if (text) onDelta(text);
+          break;
+        }
+        if (!shouldRetryRaceArrival(lastFail) || attempt === 1) break;
+        continue;
+      }
+
+      const parsed = await readGatewayRaceStream(r, feed, hooks.signal);
+      for (const a of parsed.arrivals) {
+        arrivals.push(a);
+        if (isRaceCountable(a)) {
+          done.push(a);
+          feed.onBack();
+        } else {
+          feed.onFail(a.model);
+        }
+      }
+      lastFail = parsed.arrivals[parsed.arrivals.length - 1] || lastFail;
+      if (done.length >= want || !shouldRetryRaceArrival(lastFail) || attempt === 1) break;
+    } catch (e) {
+      lastFail = { model: 'gateway', text: '', error: e?.message || 'error' };
+      arrivals.push(lastFail);
+      if (!shouldRetryRaceArrival(lastFail) || attempt === 1) break;
+    }
+  }
+
+  const cands = done.slice(0, want);
+  if (!cands.length) return ship(raceLastShip(arrivals));
+  if (cands.length === 1) return ship(cands[0]);
+
+  onStatus?.('judging…');
+  const scored = await Promise.all(cands.map(async (c) => {
+    let score = 0;
+    try { score = Number(await classify(messages, c)) || 0; } catch { score = 0; }
+    return { ...c, score };
+  }));
+  let picked = pickRaceWinner(scored, minScore);
+  if (picked.reason === 'tie' && picked.tied.length > 1) {
+    let broken = null;
+    try { broken = await pairwise(messages, picked.tied); } catch { /* last of the tie */ }
+    const usable = broken && String(broken.text || '').trim();
+    picked = { winner: usable ? broken : picked.tied[picked.tied.length - 1], reason: 'tiebreak', tied: picked.tied };
+  }
+  return ship(picked.winner || scored[scored.length - 1] || raceLastShip(arrivals));
+}
+
+async function readGatewayRaceStream(r, feed, signal) {
+  const reader = r.body.getReader();
+  const decoder = new TextDecoder();
+  let buf = '';
+  const texts = new Map();
+  const finished = new Map();
+  const live = { id: null };
+  const stopWait = startModelWait(() => {});
+
+  const pushText = (id, chunk) => {
+    if (chunk == null || chunk === '') return;
+    const key = id || live.id || 'gateway';
+    live.id = key;
+    texts.set(key, (texts.get(key) || '') + chunk);
+    feed.onToken(key, chunk);
+  };
+  const finishOne = (id, extra = {}) => {
+    const key = id || live.id || 'gateway';
+    if (finished.has(key)) return;
+    const text = extra.text != null ? String(extra.text) : (texts.get(key) || '');
+    const row = { model: extra.model || key, text, error: extra.error };
+    finished.set(key, row);
+  };
+
+  try {
+    for (;;) {
+      if (signal?.aborted) break;
+      let chunk;
+      try {
+        chunk = await readWithIdleTimeout(reader, STREAM_IDLE_MS);
+      } catch (e) {
+        if (e?.code !== 'STREAM_IDLE') throw e;
+        try { await reader.cancel(); } catch { /* already */ }
+        break;
+      }
+      const { value, done } = chunk;
+      if (done) break;
+      buf += decoder.decode(value, { stream: true });
+      const lines = buf.split('\n');
+      buf = lines.pop();
+      for (const line of lines) {
+        const s = line.trim();
+        if (s.startsWith(': race ')) {
+          try {
+            const ev = JSON.parse(s.slice(7));
+            const id = raceRacerId(ev, 'gateway');
+            if (ev.text && ev.event !== 'fail') pushText(id, ev.text);
+            if (ev.event === 'token' && ev.delta) pushText(id, ev.delta);
+            if (ev.event === 'back' || ev.event === 'done' || ev.finish) {
+              finishOne(id, { text: ev.text, model: ev.model });
+            }
+            if (ev.event === 'fail' || ev.error) {
+              finishOne(id, { text: ev.text || '', error: ev.error || 'empty body', model: ev.model });
+            }
+          } catch { /* keep-alive */ }
+          continue;
+        }
+        if (s.startsWith(': x402 ')) continue; // metered by the sidecar; never log
+        if (!s.startsWith('data:')) continue;
+        const payload = s.slice(5).trim();
+        if (payload === '[DONE]') continue;
+        try {
+          const obj = JSON.parse(payload);
+          const ev = raceEventOf(obj);
+          const c = obj?.choices?.[0];
+          const d = c?.delta;
+          const id = raceRacerId(obj, live.id || 'gateway');
+          if (d?.content) pushText(id, d.content);
+          else if (d?.reasoning || d?.reasoning_content) { /* thinking — not content */ }
+          if (c?.finish_reason) finishOne(id, { model: obj.model });
+          if (ev?.ev === 'back' || ev?.ev === 'done') finishOne(ev.id, { text: ev.text, model: ev.id });
+          if (ev?.ev === 'fail' || ev?.error) finishOne(ev.id, { text: ev.text || '', error: ev.error || 'empty body' });
+          const msg = c?.message?.content || obj?.choices?.[0]?.message?.content;
+          if (msg && (c?.finish_reason || obj.object === 'chat.completion')) {
+            pushText(id, texts.has(id) ? '' : msg);
+            if (!texts.get(id)) texts.set(id, String(msg));
+            finishOne(id, { text: texts.get(id) || msg, model: obj.model || id });
+          }
+        } catch { /* partial JSON */ }
+      }
+    }
+  } finally {
+    stopWait();
+    try { await reader.cancel(); } catch { /* closed */ }
+  }
+
+  if (!finished.size && texts.size) {
+    for (const [id, text] of texts) finishOne(id, { text });
+  }
+  const arrivals = [...finished.values()];
+  if (!arrivals.length) arrivals.push({ model: 'gateway', text: '', error: 'empty body' });
+  return { arrivals };
+}
+
 /**
  * Launch N models at once, judge the FIRST K that come back.
  *
@@ -693,10 +944,33 @@ export async function brainRace(messages, onDelta, contextId, models, need = 1,
   const classify = hooks.classify || classifyRaceAnswer;
   const pairwise = hooks.pairwise || pairwiseTied;
   const minScore = hooks.minScore != null ? Number(hooks.minScore) : RACE_MIN_SCORE;
-  const list = (models || []).filter(Boolean).slice(0, RACE_MAX);
+  let list = (models || []).filter(Boolean).slice(0, RACE_MAX);
+  const budget = await raceBudget(hooks);
+  const capped = capRaceByCredit(list.length, budget);
+  if (capped.n < 1) {
+    onStatus?.('race refused — no credit');
+    return RACE_NO_CREDIT;
+  }
+  if (capped.n < list.length) {
+    list = list.slice(0, capped.n);
+    onStatus?.(capped.n < 2 ? 'race shrunk to 1 — credit' : `race shrunk to ${capped.n} — credit`);
+  }
   if (list.length < 2) return stream(messages, onDelta, contextId, list[0], maxTokens, 0, 0, onStatus);
   const want = Math.max(1, Math.min(Number(need) || 1, list.length));
 
+  // One Fly settle when the completions door honors `race:`. Custom stream
+  // hooks (unit tests of the N-parallel judge) keep the old path. Old
+  // sidecar / local mock that does not accept race: also stays N-parallel.
+  const customStream = Boolean(hooks.stream);
+  let gateway = hooks.gatewayRace;
+  if (gateway == null && !customStream) {
+    try { gateway = await probeGatewayRace(hooks.proxy || completionsProxy(), hooks.fetch || fetch); }
+    catch { gateway = false; }
+  }
+  if (gateway && !customStream) {
+    return brainGatewayRace(messages, onDelta, contextId, list, want, maxTokens, onStatus, hooks);
+  }
+
   const feed = createRaceFeed(onDelta, onStatus, want);
   feed.start();
 

package/lib/proxy.js

@@ -26,6 +26,7 @@ import { loadSessionSpend, saveSessionSpend } from './session.js';
 import { creditBalance, quotedPrices } from './info.js';
 import { subscriptionPublicView } from './subscription.js';
 import { priceHoldings } from './livestatus.js';
+import { receiptUsedCogs } from './racesettle.js';
 
 const HOP_BY_HOP = new Set([
   'host', 'connection', 'keep-alive', 'transfer-encoding', 'upgrade',
@@ -781,6 +782,7 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
     console.log(line);
   };
   let sessionSpent = restored.spentUsd;
+  let lastQuoteUsd = null;
   let sessionCogs = restored.cogsUsd;
   let sessionDirect = restored.directUsd;
   const rememberSpend = () => {
@@ -791,6 +793,12 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
   }
   process.on('exit', rememberSpend);
   const MARKUP = 3; // confirmed constant, see .claude/wiki.md "Margin needs a like-for-like denominator"
+  const noteQuote = (x) => {
+    const billed = Number(x?.billedUsd);
+    if (!Number.isFinite(billed) || billed < 0) return;
+    const n = Number(x?.race || x?.race_n || 1);
+    lastQuoteUsd = n > 1 ? billed / n : billed;
+  };
   let tunnelSpent = 0;
   // Live balance refresh state — the real implementation is assigned in the
   // banner section below; the handler only ever calls scheduleRefresh().
@@ -894,7 +902,7 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       res.writeHead(200, { 'content-type': 'application/json' });
       res.end(JSON.stringify({
         spentUsd: sessionSpent, cogsUsd: sessionCogs, directUsd: sessionDirect, paidCalls,
-        creditUsd, chainUsd: money.chainUsd,
+        creditUsd, chainUsd: money.chainUsd, lastQuoteUsd,
         subscription: subscriptionPublicView(),
       }));
       return;
@@ -1519,9 +1527,8 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
           // is only correct on a straight-markup call: under counterfactual
           // pricing billedUsd is min(direct×discount, markupUsd), so the
           // division understates cost and overstates margin.
-          sessionCogs += typeof receipt.cogsUsd === 'number'
-            ? receipt.cogsUsd
-            : receipt.billedUsd / MARKUP;
+          sessionCogs += receiptUsedCogs(receipt, MARKUP);
+          noteQuote(receipt);
           // direct = what answering this WITHOUT the zoo would have cost. On an
           // attach call that is the whole bound corpus, which is why it can be
           // orders of magnitude above what was billed. directUsd is exact and
@@ -1591,7 +1598,8 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         if (!paid && data?.x402 && typeof data.x402.billedUsd === 'number') {
           const x = data.x402;
           sessionSpent += x.billedUsd;
-          sessionCogs += typeof x.cogsUsd === 'number' ? x.cogsUsd : x.billedUsd / MARKUP;
+          sessionCogs += receiptUsedCogs(x, MARKUP);
+          noteQuote(x);
           sessionDirect += typeof x.directUsd === 'number' ? x.directUsd : x.billedUsd;
           if (didSpill) {
             // THE number that settles why a spilled call did or did not save:
@@ -1656,7 +1664,8 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       const meterStreamed = (x) => {
         if (paid || typeof x?.billedUsd !== 'number') return;
         sessionSpent += x.billedUsd;
-        sessionCogs += typeof x.cogsUsd === 'number' ? x.cogsUsd : x.billedUsd / MARKUP;
+        sessionCogs += receiptUsedCogs(x, MARKUP);
+        noteQuote(x);
         sessionDirect += typeof x.directUsd === 'number' ? x.directUsd : x.billedUsd;
         if (typeof x.actualUsd === 'number' && x.actualUsd >= 0) { sessionActual += x.actualUsd; actualCalls += 1; billedWithActual += x.billedUsd || 0; }
         if (didSpill) {

package/lib/racesettle.js

@@ -0,0 +1,143 @@
+/**
+ * Fly gateway race: one POST { race, race_need, tier }, unused grant-back,
+ * and HUD cogs for the racers that actually ran — never the N+judge ceiling.
+ */
+
+export const FLY_GATEWAY_HOST = 'x402-tokens.fly.dev';
+export const RACE_NO_CREDIT = '(race: not enough prepaid credit — shrink N or top up, rather than fire on $0)';
+
+const FLY_RE = /x402-tokens\.fly\.dev/i;
+
+/** Completions door is the Fly gateway (sidecar → x402-tokens.fly.dev). */
+export function isFlyGatewayUpstream(upstream) {
+  return FLY_RE.test(String(upstream || ''));
+}
+
+/**
+ * Whether this completions door will honor `race:` on POST /chat/completions.
+ * Fly (and a test mock that advertises it) → true. Old sidecar / local mock → false.
+ */
+export function doorAcceptsRace(info) {
+  if (!info || typeof info !== 'object') return false;
+  if (info.race === true || info.gatewayRace === true) return true;
+  if (info.race === false || info.gatewayRace === false) return false;
+  const features = info.features || info.caps || info.capabilities;
+  if (Array.isArray(features) && features.some((f) => String(f).toLowerCase() === 'race')) return true;
+  if (features && typeof features === 'object' && (features.race === true || features.gatewayRace === true)) {
+    return true;
+  }
+  return isFlyGatewayUpstream(info.upstream || info.apiBase || info.gateway);
+}
+
+let probeCache = { at: 0, ok: null, proxy: '' };
+
+export function resetGatewayRaceProbe() {
+  probeCache = { at: 0, ok: null, proxy: '' };
+}
+
+function proxyOrigin(proxy) {
+  const raw = String(proxy || '').replace(/\/+$/, '');
+  return raw.replace(/\/v1$/i, '');
+}
+
+/**
+ * Probe the sidecar / mock once. GET /v1/info (and /info) — never a paid
+ * completions call. Cached briefly so a race of 4 does not fan out probes.
+ */
+export async function probeGatewayRace(proxy, fetchFn = fetch, ttlMs = 60_000) {
+  const key = String(proxy || '');
+  if (probeCache.ok != null && probeCache.proxy === key && Date.now() - probeCache.at < ttlMs) {
+    return probeCache.ok;
+  }
+  const origin = proxyOrigin(key);
+  if (!origin) {
+    probeCache = { at: Date.now(), ok: false, proxy: key };
+    return false;
+  }
+  const paths = ['/v1/info', '/info'];
+  for (const p of paths) {
+    try {
+      const r = await fetchFn(`${origin}${p}`, { signal: AbortSignal.timeout(1500) });
+      if (!r.ok) continue;
+      const j = await r.json().catch(() => null);
+      const ok = doorAcceptsRace(j);
+      probeCache = { at: Date.now(), ok, proxy: key };
+      return ok;
+    } catch { /* try next */ }
+  }
+  probeCache = { at: Date.now(), ok: false, proxy: key };
+  return false;
+}
+
+/**
+ * If prepaid credit is known and `n × quote > credit`, shrink n (or 0 = refuse)
+ * rather than fire 4 groks on $0 credit. Unknown credit/quote → leave n alone.
+ */
+export function capRaceByCredit(n, { creditUsd, quoteUsd } = {}) {
+  const want = Math.max(0, Math.floor(Number(n) || 0));
+  if (creditUsd == null || !Number.isFinite(Number(creditUsd))) {
+    return { n: want, reason: null };
+  }
+  const credit = Number(creditUsd);
+  if (credit <= 0) return { n: 0, reason: 'no-credit' };
+  const quote = Number(quoteUsd);
+  if (!Number.isFinite(quote) || quote <= 0) {
+    // Credit is known and positive but we have no per-entrant quote — do not
+    // invent one. A $0 balance already refused above.
+    return { n: want, reason: null };
+  }
+  if (want * quote <= credit) return { n: want, reason: null };
+  const maxN = Math.floor(credit / quote);
+  if (maxN < 1) return { n: 0, reason: 'no-credit' };
+  return { n: Math.min(want, maxN), reason: 'shrunk' };
+}
+
+function unusedGrant(x) {
+  const u = x?.race_unused ?? x?.raceUnused ?? x?.unused;
+  if (u == null) return { billed: 0, cogs: 0 };
+  if (typeof u === 'number' && Number.isFinite(u)) return { billed: u, cogs: u };
+  if (typeof u !== 'object') return { billed: 0, cogs: 0 };
+  const billed = Number(u.billedUsd ?? u.refundUsd ?? u.unusedBilledUsd ?? u.usd ?? 0);
+  const cogs = Number(u.cogsUsd ?? u.unusedCogsUsd ?? u.refundCogsUsd ?? billed);
+  return {
+    billed: Number.isFinite(billed) && billed > 0 ? billed : 0,
+    cogs: Number.isFinite(cogs) && cogs > 0 ? cogs : 0,
+  };
+}
+
+/**
+ * Actual used-racer cogs after unused grant-back.
+ * Never the N+judge ceiling. Does not clamp to billed — HUD embers when
+ * used cogs still exceed what was paid.
+ */
+export function receiptUsedCogs(x, markup = 3) {
+  if (!x || typeof x !== 'object') return 0;
+  const billedRaw = Number(x.billedUsd);
+  const billedOk = Number.isFinite(billedRaw) && billedRaw >= 0;
+  let cogs = typeof x.cogsUsd === 'number' && Number.isFinite(x.cogsUsd)
+    ? x.cogsUsd
+    : (billedOk ? billedRaw / markup : 0);
+  const grant = unusedGrant(x);
+  if (grant.cogs > 0) cogs = Math.max(0, cogs - grant.cogs);
+  return cogs;
+}
+
+/**
+ * Session meter. spent/direct are the receipt totals (already net of unused
+ * when the gateway refunds into billedUsd) — never a first-call rewrite.
+ * cogs is used racers after unused grant-back.
+ */
+export function meterRaceReceipt(x, markup = 3) {
+  const billed = Number(x?.billedUsd);
+  const spentUsd = Number.isFinite(billed) ? billed : 0;
+  const usedCogs = receiptUsedCogs(x, markup);
+  const direct = typeof x?.directUsd === 'number' ? x.directUsd : spentUsd;
+  return { spentUsd, cogsUsd: usedCogs, directUsd: direct };
+}
+
+export function inferRaceTier(models, fallback = 'medium') {
+  const list = Array.isArray(models) ? models : [];
+  const grok = list.filter((m) => /^x-ai\/grok/i.test(String(m)));
+  if (list.length && grok.length === list.length) return 'grok4.6';
+  return fallback;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openzoo",
-  "version": "0.49.0",
+  "version": "0.49.2",
   "description": "Local x402-paying proxy + MCP server for openzoo.fun \u2014 point any OpenAI-compatible harness (Cursor, Claude Code, aider, SDKs) at localhost and it pays per call from a local burner wallet. Solana and Base rails live; Robinhood experimental.",
   "license": "MIT",
   "type": "module",