openzoo 0.49.1 → 0.49.3

package/lib/grokui.mjs

@@ -691,6 +691,7 @@ const AUTO_RACE_RETRY = 'AUTO is still on — the last model call failed (race/e
   + '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_EMPTY_RETRY = 'AUTO_EMPTY_RETRY: the command produced no output, try a different command or a different path, do not stop.';
 // 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.
@@ -709,13 +710,43 @@ function isTransientModelFail(text) {
 function isPaymentFailed(text) {
   return /\b(?:payment failed|HTTP 402|wallet is empty|empty wallet)\b/i.test(String(text || ''));
 }
+// Empty stdout, "(no output)", or a directive that found nothing. That is
+// still a command-output hop today, so AUTO used to chain once and then park
+// as if the job had succeeded. It has not — try another command or path.
+function isEmptyExecOutput(text) {
+  const s = String(text ?? '').trim();
+  return !s || s === '(no output)';
+}
+function isEmptyDirectiveAck(text) {
+  const s = String(text ?? '').trim();
+  if (isEmptyExecOutput(s)) return true;
+  if (/:\s*\(empty\)$/i.test(s)) return true;
+  if (/:\s*no matches\s*$/i.test(s)) return true;
+  return false;
+}
+function isEmptyToolResult(text) {
+  if (text == null) return false;
+  const s = String(text).trim();
+  if (isEmptyExecOutput(s)) return true;
+  const cmd = /^\(command output\)\s*([\s\S]*)$/.exec(s);
+  if (cmd) return isEmptyExecOutput(cmd[1]);
+  const dir = /^\(directive result\)\s*([\s\S]*)$/.exec(s);
+  if (dir) return isEmptyDirectiveAck(dir[1]);
+  return false;
+}
+function isEmptyShownRun(text) {
+  const shown = /^\$ [^\n]*\n([\s\S]*)$/.exec(String(text ?? ''));
+  return Boolean(shown && isEmptyExecOutput(shown[1]));
+}
 // Park only: ask mode, pendingRun, DONE:, 402/empty-wallet, or the hard cap.
-function shouldKeepAuto(t, reply) {
+// Empty /(no output) exec is not DONE — keep going with AUTO_EMPTY_RETRY.
+function shouldKeepAuto(t, reply, userText) {
   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;
+  if (isEmptyToolResult(userText) || isEmptyShownRun(reply)) return true;
+  if (isDoneReply(reply)) return false;
   return true;
 }
 function enqueueAutoHop(t, threadId, userText, onEvent) {
@@ -725,7 +756,8 @@ function enqueueAutoHop(t, threadId, userText, onEvent) {
   kickTurn(threadId, userText, onEvent).catch(() => {});
   return true;
 }
-function autoHopText(reply) {
+function autoHopText(reply, userText) {
+  if (isEmptyToolResult(userText) || isEmptyShownRun(reply)) return AUTO_EMPTY_RETRY;
   return isTransientModelFail(reply) ? AUTO_RACE_RETRY : AUTO_CONTINUE;
 }
 // PING used to be a read: last-line status, no turn. Idle children stayed idle
@@ -805,7 +837,8 @@ 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.`;
+a real blocking question, or the step cap. Empty output, "(no output)", and
+GLOB/GREP with no matches are not finished — try a different command or path.`;
 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
@@ -992,7 +1025,7 @@ function execCommand(command, cwd) {
     exec(command, { cwd, shell: RUN_SHELL, timeout: RUN_TIMEOUT_MS, maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
       let out = (stdout || '') + (stderr ? '\n' + stderr : '');
       if (err) out += `\n(exit ${err.code ?? 1})`;
-      resolve(keepWhole(out) || '(no output)');
+      resolve(keepWhole(out).trim() || '(no output)');
     });
   });
 }
@@ -1411,7 +1444,7 @@ setInterval(() => {
     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(() => {});
+      kickTurn(t.id, autoHopText(lastText)).catch(() => {});
     } else {
       t.status = 'idle';
       t.liveStatus = '';
@@ -1676,7 +1709,9 @@ function isHarnessUserText(text) {
   return /^\((command output|directive result)\)/.test(String(text || ''))
     || String(text || '') === NUDGE
     || String(text || '') === AUTO_CONTINUE
-    || String(text || '') === AUTO_RACE_RETRY;
+    || String(text || '') === AUTO_RACE_RETRY
+    || String(text || '') === AUTO_EMPTY_RETRY
+    || String(text || '').startsWith('AUTO_EMPTY_RETRY:');
 }
 
 function firstUserAsk(t) {
@@ -2502,8 +2537,8 @@ async function runTurn(threadId, userText, onEvent, images) {
     }
     bindThread(t).catch(() => {});
     lastReply = memberReply;
-    if (shouldKeepAuto(t, memberReply)) {
-      chained = enqueueAutoHop(t, threadId, autoHopText(memberReply), onEvent);
+    if (shouldKeepAuto(t, memberReply, userText)) {
+      chained = enqueueAutoHop(t, threadId, autoHopText(memberReply, userText), onEvent);
     }
     return;
   }
@@ -2569,6 +2604,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.
@@ -2637,7 +2673,11 @@ async function runTurn(threadId, userText, onEvent, images) {
       // 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);
+      chained = enqueueAutoHop(
+        t, threadId,
+        isEmptyExecOutput(output) ? AUTO_EMPTY_RETRY : condense('(command output)', output),
+        onEvent,
+      );
       return;
     }
     {
@@ -2667,8 +2707,12 @@ 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
-      && !isDoneReply(reply)) {
-    chained = enqueueAutoHop(t, threadId, condense('(directive result)', ack), onEvent);
+      && (isEmptyDirectiveAck(ack) || !isDoneReply(reply))) {
+    chained = enqueueAutoHop(
+      t, threadId,
+      isEmptyDirectiveAck(ack) ? AUTO_EMPTY_RETRY : condense('(directive result)', ack),
+      onEvent,
+    );
     return;
   }
 
@@ -2698,17 +2742,18 @@ async function runTurn(threadId, userText, onEvent, images) {
 
   // 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);
+  if (shouldKeepAuto(t, reply, userText)) {
+    chained = enqueueAutoHop(t, threadId, autoHopText(reply, userText), onEvent);
     return;
   }
   bindThread(t).catch(() => {});
   } finally {
     // Idle only when this hop should not keep AUTO going: DONE:, pendingRun,
-    // ask mode, 402/empty-wallet, or the hard cap. Otherwise kick again.
+    // ask mode, 402/empty-wallet, or the hard cap. Empty /(no output) is not
+    // DONE — AUTO_EMPTY_RETRY. Otherwise kick again.
     if (stillMine() && !chained && !parked) {
-      if (shouldKeepAuto(t, lastReply)) {
-        enqueueAutoHop(t, threadId, autoHopText(lastReply), onEvent);
+      if (shouldKeepAuto(t, lastReply, userText)) {
+        enqueueAutoHop(t, threadId, autoHopText(lastReply, userText), onEvent);
       } else if (!t.pendingRun) {
         t.status = 'idle';
         t.liveStatus = '';
@@ -4952,9 +4997,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');
@@ -4967,19 +5017,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). Ember when cogs > spent —
+        // house losing. Do not treat race_unused as a user refund.
+        if (cogsOver) {
+          hintEl.className = 'hhint show';
+          hintEl.innerHTML = '<b>cogs above paid.</b> house is losing — our cost exceeded what you were billed. '
+            + 'you pay for every entrant we actually launched; failures still cost us.';
+        } 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) {
@@ -5410,8 +5467,8 @@ export {
   tryDirective, ensureWorkspacePort, isPreviewableRel, previewAck, workspaceFileUrl,
   parseRun, looksLikeMcpAsBash, stripThinkTags, safeResolveIn, inDir, listDir,
   handleSlash, newThread, setRunTurnForTest, setBrainAskForTest, runTurn,
-  AUTO_CONTINUE, AUTO_RACE_RETRY, pingWakeText, pingCanWake, shouldKeepAuto,
-  isDoneReply, isTransientModelFail, enqueueAutoHop, childKickoff, findByName,
+  AUTO_CONTINUE, AUTO_RACE_RETRY, AUTO_EMPTY_RETRY, pingWakeText, pingCanWake, shouldKeepAuto,
+  isDoneReply, isTransientModelFail, isEmptyToolResult, 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.
  *
@@ -685,6 +936,7 @@ export async function tierModels(tier, n = 1, random = false) {
  *
  * Every entrant is paid for, including the abandoned one — this trades money
  * for latency and quality, which is why it is opt-in and capped.
+ * grokui does not grant unused or failed racers back to the user.
  *
  * `hooks` is for tests: `{ stream, classify, pairwise, minScore }`.
  */
@@ -693,10 +945,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,129 @@
+/**
+ * Fly gateway race: one POST { race, race_need, tier }.
+ * User pays for every entrant we actually launched. Failures still cost us
+ * (OpenRouter was paid). race_unused on a receipt is informational — do not
+ * treat it as a user refund or shrink HUD cogs to hide a house loss.
+ * HUD embers when cogs > spent.
+ */
+
+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' };
+}
+
+/**
+ * House cost from the receipt. Do not subtract race_unused — unused
+ * grant-back is not a user refund, and shrinking cogs would hide house loss.
+ * Does not clamp to billed — HUD embers when cogs 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;
+  if (typeof x.cogsUsd === 'number' && Number.isFinite(x.cogsUsd)) return x.cogsUsd;
+  return billedOk ? billedRaw / markup : 0;
+}
+
+/**
+ * Session meter. spent/direct are the receipt totals as billed — never a
+ * first-call rewrite, never a race_unused user refund.
+ * cogs is the house cost on that receipt (HUD embers when cogs > spent).
+ */
+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.1",
+  "version": "0.49.3",
   "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",