openzoo 0.48.97 → 0.48.99

package/lib/config.js

@@ -1,5 +1,6 @@
 import os from 'node:os';
 import path from 'node:path';
+import { fetchHeaders } from './fetch.js';
 
 export const config = {
   port: Number(process.env.OPENZOO_PORT || 8402),
@@ -160,7 +161,7 @@ export function unfundableRails(liveRailNames) {
  * Underlying assets only: the wrapped settlement mints are internal plumbing.
  */
 export async function liveRails() {
-  const r = await fetch(`${config.apiBase}/v1/chat/completions`, {
+  const r = await fetchHeaders(`${config.apiBase}/v1/chat/completions`, {
     method: 'POST',
     headers: { 'content-type': 'application/json' },
     body: JSON.stringify({ model: 'nvidia/nemotron-3.5-lightning', messages: [{ role: 'user', content: 'ping' }], max_tokens: 1 }),

package/lib/fetch.js

@@ -0,0 +1,46 @@
+/**
+ * Time-to-first-byte for hops to x402-tokens.fly.dev / OpenRouter.
+ *
+ * A hung keep-alive (no headers) must not pin an undici socket forever —
+ * that is what wedged GET /v1/session (LISTEN up, HTTP 000) while a
+ * brainRace of 4 sat on the same pool. Once headers arrive, the body may
+ * stream for as long as generation takes. Do not set fetch `family` here;
+ * Happy Eyeballs + ipv4first live in bin/openzoo.js.
+ */
+export const HEADERS_MS = Number(process.env.OPENZOO_UPSTREAM_HEADERS_MS || 120_000);
+export const UPSTREAM_HEADERS_MS = HEADERS_MS;
+export const CREDIT_TIMEOUT_MS = Number(process.env.OPENZOO_CREDIT_TIMEOUT_MS || 2_500);
+
+export function headersMs() {
+  const n = Number(process.env.OPENZOO_UPSTREAM_HEADERS_MS || 120_000);
+  return Number.isFinite(n) && n > 0 ? n : 120_000;
+}
+
+function mergeSignal(existing, timeout) {
+  if (!existing) return timeout;
+  if (typeof AbortSignal.any === 'function') return AbortSignal.any([existing, timeout]);
+  const c = new AbortController();
+  const abort = () => { try { c.abort(); } catch { /* already */ } };
+  if (existing.aborted || timeout.aborted) { abort(); return c.signal; }
+  existing.addEventListener('abort', abort, { once: true });
+  timeout.addEventListener('abort', abort, { once: true });
+  return c.signal;
+}
+
+/** fetch that aborts if headers have not arrived in `ms`, then lets the stream run. */
+export async function fetchHeaders(url, init = {}, ms = headersMs()) {
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), ms);
+  timer.unref?.();
+  try {
+    const res = await fetch(url, {
+      ...init,
+      signal: mergeSignal(init.signal, ac.signal),
+    });
+    clearTimeout(timer);
+    return res;
+  } catch (err) {
+    clearTimeout(timer);
+    throw err;
+  }
+}

package/lib/grokui.mjs

@@ -11,8 +11,8 @@ import { randomUUID } from 'node:crypto';
 import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import { cpus, homedir } from 'node:os';
 import path from 'node:path';
-import { adaptiveTopK, brain, brainRace, brainStream, tierModels, MODEL, PROXY, TIER_NAMES } from './podagent.mjs';
-import { peekDirectiveStatus, formatRaceStatus, STALE_THINKING_MS } from './livestatus.js';
+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 { creditBalance } from './info.js';
 import {
   SUBSCRIPTIONS_PAGE,
@@ -404,6 +404,7 @@ actually calls for delegation or file work.`;
 
 // id -> { id, name, color, parent, messages: [{role,content}], history: [{who,text}], status }
 const threads = new Map();
+const turnAborts = new WeakMap();
 
 // Threads are the whole point of the app — losing them on every restart (the
 // server got restarted a lot while iterating this session) is a real bug, not
@@ -632,10 +633,10 @@ function newGroupThread(names) {
 }
 
 // Real leCore binding — POST /v1/hrr/bind on the local proxy, same free
-// passthrough the wiki documents. Fire-and-forget after each turn: the next
-// turn's brain()/brainStream() call picks up t.contextId once it lands, via
-// the X-HRR-Context header, so retrieval is real and automatic, not a prompt
-// claim about a mechanism that doesn't exist.
+// passthrough the wiki documents. Fire-and-forget after each turn so the
+// project corpus stays bound. Completions must NOT send X-HRR-Context:
+// sidecar maybeCacheCorpus skips spill when that header is set, which is
+// the path `npx openzoo claude` uses (bind-prefix / send-3/131-turns).
 // Chunked, not one shot: a single request over ~8MB (post JSON-escaping)
 // gets rejected, so a large/growing thread's bind would silently fail past
 // whatever point it crossed that line — confirmed live by a bot's own RUN
@@ -950,7 +951,7 @@ const SLASH_COMMANDS = [
   { name: '/tokens', args: '', help: 'tokens and calls this session' },
   { name: '/model', args: '[id]', help: 'show or switch this thread’s model' },
   { name: '/models', args: '[filter]', help: 'search the ~435 served models' },
-  { name: '/tier', args: 'cheap|medium|expensive', help: 'how much to spend per turn when no model is pinned' },
+  { name: '/tier', args: 'cheap|medium|expensive|grok 4.6', help: 'how much to spend per turn when no model is pinned' },
   { name: '/race', args: '<n> | <k> <n>', help: 'launch n models; judge the first k back (k=1 = fastest wins)' },
   { name: '/compact', args: '', help: 'summarise history to shrink context' },
   { name: '/clear', args: '', help: 'wipe this thread’s history' },
@@ -1005,9 +1006,10 @@ function condense(label, text) {
   if (s.length <= FEEDBACK_MAX) return `${label}\n${s}`;
   const head = s.slice(0, Math.floor(FEEDBACK_MAX * 0.7));
   const tail = s.slice(-Math.floor(FEEDBACK_MAX * 0.3));
-  // The wording matters. Retrieval is AUTOMATIC — the thread's context id
-  // rides on every call as x-hrr-context and leCore injects whatever slice is
-  // relevant to what you say next. Telling the model to "ask for it" invites
+  // The wording matters. Retrieval is AUTOMATIC — sidecar spill binds the
+  // transcript the same way Claude CLI does (maybeCacheCorpus), and leCore
+  // injects whatever slice is relevant to what you say next. Telling the
+  // model to "ask for it" invites
   // it to invent a RECALL directive that does not exist, which is the exact
   // failure mode this whole harness keeps hitting: a model fabricating a
   // mechanism instead of using the real one.
@@ -1027,7 +1029,7 @@ function emitToThread(threadId, ev) {
 }
 
 async function sessionStats() {
-  try { return await (await fetch(`${PROXY}/session`)).json(); }
+  try { return await (await fetch(`${PROXY}/session`, { signal: AbortSignal.timeout(2000) })).json(); }
   catch { return null; }
 }
 
@@ -1108,8 +1110,8 @@ async function handleSlash(task, t) {
         + (t.model ? `NOTE: /model ${t.model} is pinned on this thread, so the tier is ignored until you /model default.\n` : '')
         + 'Switch with  /tier <name>   ·  /race <n> to ask several at once.';
     }
-    const want = arg.trim().toLowerCase();
-    if (!TIER_NAMES.includes(want)) return `Unknown tier "${arg}". One of: ${TIER_NAMES.join(', ')}.`;
+    const want = normalizeTier(arg);
+    if (!want) return `Unknown tier "${arg}". One of: ${TIER_NAMES.join(', ')} (also: grok 4.6).`;
     t.tier = want; saveThreads();
     const picks = await tierModels(want, 3);
     return `This thread now runs on the ${want} tier — ${picks.join(', ')}…`
@@ -1328,6 +1330,7 @@ setInterval(() => {
     const last = t.lastDeltaAt || t.thinkingAt || 0;
     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 = '';
     dirty = true;
@@ -2318,7 +2321,7 @@ async function runTurn(threadId, userText, onEvent, images) {
   const stillMine = () => threads.get(threadId)?.turnSeq === seq;
   const paint = (ev) => {
     if (!stillMine()) return;
-    if (ev.type === 'status' && ev.detail) t.liveStatus = ev.detail;
+    if (ev.type === 'status' && ev.detail && t.status === 'thinking') t.liveStatus = ev.detail;
     if (ev.type === 'delta' || ev.type === 'status' || ev.type === 'start') t.lastDeltaAt = Date.now();
     onEvent?.(ev);
   };
@@ -2327,6 +2330,9 @@ async function runTurn(threadId, userText, onEvent, images) {
   t.status = 'thinking';
   t.thinkingAt = Date.now();
   t.lastDeltaAt = Date.now();
+  try { turnAborts.get(t)?.abort(); } catch { /* none */ }
+  const turnAbort = new AbortController();
+  turnAborts.set(t, turnAbort);
   const raceN = Math.min(Number(t.race) || 0, 4);
   const raceNeed = Math.min(Math.max(Number(t.raceNeed) || 1, 1), raceN || 1);
   t.liveStatus = (!t.model && raceN >= 2) ? formatRaceStatus(0, raceNeed) : 'waiting on model…';
@@ -2433,7 +2439,10 @@ async function runTurn(threadId, userText, onEvent, images) {
       // setting the latency. Collection is first-X-back (non-empty);
       // classify runs only on those X.
       const need = Math.min(Math.max(Number(t.raceNeed) || 1, 1), race);
-      return (await brainRace(callMsgs, emit, t.contextId, models, need, undefined, emitStatus)).trim();
+      return (await brainRace(callMsgs, emit, t.contextId, models, need, undefined, emitStatus, {
+        signal: turnAbort.signal,
+        onArrivals: (arr) => { t.lastRaceFail = summarizeRaceFailures(arr); },
+      })).trim();
     }
     // A retry draws a DIFFERENT model from the tier rather than the same one.
     const model = t.model || (await tierModels(t.tier || 'medium', attempt + 1, attempt > 0))[attempt] || undefined;
@@ -3212,6 +3221,7 @@ const APP_HTML = `<!doctype html>
         <option value="cheap">cheap</option>
         <option value="medium" selected>medium</option>
         <option value="expensive">expensive</option>
+        <option value="grok4.6">grok 4.6</option>
       </select>
       <select class="dial" id="raceSel" data-component="model-race" aria-label="Race models"
               title="Ask N models from the tier at once, drawn at random — fastest real answer wins. You pay for every entrant.">
@@ -3622,7 +3632,7 @@ const APP_HTML = `<!doctype html>
           : 'Ask N models from the tier at once, drawn at random — fastest real answer wins. You pay for every entrant.';
     }
     if (!pinned && (t.tier === 'expensive' || (t.race || 0) >= 2)) {
-      if (t.tier === 'expensive') tierSel.className = 'dial hot';
+      if (t.tier === 'expensive' || t.tier === 'grok4.6') tierSel.className = 'dial hot';
       if ((t.race || 0) >= 2) raceSel.className = 'dial hot';
     }
   }
@@ -5066,7 +5076,7 @@ const server = http.createServer((req, res) => {
   if (req.method === 'GET' && req.url === '/hud-summary') {
     (async () => {
       let you = { spentUsd: 0, cogsUsd: 0, directUsd: 0, paidCalls: 0, creditUsd: null, chainUsd: null };
-      try { you = { ...you, ...(await (await fetch('http://127.0.0.1:8402/v1/session')).json()) }; }
+      try { you = { ...you, ...(await (await fetch('http://127.0.0.1:8402/v1/session', { signal: AbortSignal.timeout(2000) })).json()) }; }
       catch { /* local proxy not running — HUD shows zeros rather than guessing */ }
       try {
         you.creditUsd = await creditBalance();
@@ -5154,7 +5164,8 @@ const server = http.createServer((req, res) => {
     res.writeHead(200, { 'content-type': 'application/json' });
     res.end(t ? JSON.stringify({
       id: t.id, history: t.history, status: t.status,
-      liveStatus: t.liveStatus || '',
+      liveStatus: t.status === 'thinking' ? (t.liveStatus || '') : '',
+      lastRaceFail: t.lastRaceFail || null,
       workspacePort: workspacePort || 0, dir: t.dir || WORKSPACE_DIR,
     }) : '{}');
     return;

package/lib/info.js

@@ -4,6 +4,7 @@ import { config, FUNDING_ASSETS, EVM_FUNDING_ASSETS, evmRpcFor, fundingLine } fr
 import { loadOrCreateWallet } from './wallet.js';
 import { tokenBalance } from './x402.js';
 import { evmTokenBalance, evmNativeBalance } from './evm.js';
+import { CREDIT_TIMEOUT_MS, fetchHeaders } from './fetch.js';
 
 export function printAddress() {
   const { keypair, evmPrivateKey, created, path } = loadOrCreateWallet();
@@ -51,7 +52,7 @@ export async function quotedPrices() {
     //
     // The chat challenge prices each asset at its real spot (DexScreener), and
     // needs no namespace signature, so it is both correct and simpler.
-    const r = await fetch(`${config.apiBase}/v1/chat/completions`, {
+    const r = await fetchHeaders(`${config.apiBase}/v1/chat/completions`, {
       method: 'POST',
       headers: { 'content-type': 'application/json' },
       body: JSON.stringify({ model: config.defaultModel || 'anthropic/claude-sonnet-5', max_tokens: 1, messages: [{ role: 'user', content: 'x' }] }),
@@ -247,10 +248,15 @@ export async function topUp(usdArg) {
 export { priceHoldings, formatHoldingMoney } from './livestatus.js';
 
 /** Current prepaid credit for this wallet's namespace. */
+export { CREDIT_TIMEOUT_MS };
+
 export async function creditBalance() {
   const { withNamespace } = await import('./namespace.js');
   try {
-    const r = await fetch(`${config.apiBase}/v1/credits`, { headers: withNamespace({}) });
+    const r = await fetch(`${config.apiBase}/v1/credits`, {
+      headers: withNamespace({}),
+      signal: AbortSignal.timeout(CREDIT_TIMEOUT_MS),
+    });
     const j = await r.json();
     return Number(j.balanceUsd) || 0;
   } catch {

package/lib/livestatus.js

@@ -6,8 +6,8 @@
  * tool) and abort a reader that has gone silent.
  */
 
-export const STREAM_IDLE_MS = Number(process.env.OZ_STREAM_IDLE_MS || 55_000);
-export const STALE_THINKING_MS = Number(process.env.OZ_STALE_THINKING_MS || 90_000);
+export const STREAM_IDLE_MS = Number(process.env.OZ_STREAM_IDLE_MS || 180_000);
+export const STALE_THINKING_MS = Number(process.env.OZ_STALE_THINKING_MS || 240_000);
 export const MODEL_WAIT_TICK_MS = 1000;
 export const MODEL_WAIT_SECONDS_AFTER_MS = 2000;
 
@@ -30,8 +30,8 @@ export function formatPayStatus(attempt = 0) {
 
 /** First-X-back race: how many of the K we asked for have actually landed. */
 export function formatRaceStatus(back, need) {
-  const b = Math.max(0, Number(back) || 0);
   const n = Math.max(1, Number(need) || 1);
+  const b = Math.min(n, Math.max(0, Number(back) || 0));
   return `racing ${b}/${n} back…`;
 }
 
@@ -72,6 +72,44 @@ export function raceLastShip(arrivals) {
   return { model: '', text: RACE_EVERY_FAILED, error: true };
 }
 
+/** Classify one failed arrival without naming a model. */
+export function raceFailKind(arrival) {
+  const err = String(arrival?.error || '');
+  const text = String(arrival?.text || '').trim();
+  const s = `${err} ${text}`.trim();
+  if (!s) return 'empty body';
+  if (/timeout|STREAM_IDLE|aborted|AbortError/i.test(s)) return 'timeout';
+  if (/402|payment failed/i.test(s)) return 'pay';
+  if (/fetch failed/i.test(s)) return 'fetch failed';
+  const http = /HTTP\s+(\d{3})/i.exec(s);
+  if (http) return `HTTP ${http[1]}`;
+  if (err) return 'error';
+  if (!isRaceCountable(arrival)) return 'empty body';
+  return 'ok';
+}
+
+/** Counts of failure kinds across a race. Used for lastRaceFail on GET. */
+export function summarizeRaceFailures(arrivals) {
+  const counts = {};
+  for (const a of Array.isArray(arrivals) ? arrivals : []) {
+    const k = raceFailKind(a);
+    if (k === 'ok') continue;
+    counts[k] = (counts[k] || 0) + 1;
+  }
+  return counts;
+}
+
+/**
+ * Transient racer deaths — retry the same slot once.
+ * Pay/402 will not get better. A real answer is done.
+ */
+export function shouldRetryRaceArrival(arrival) {
+  if (isRaceCountable(arrival)) return false;
+  const k = raceFailKind(arrival);
+  return k === 'fetch failed' || k === 'timeout' || k === 'empty body'
+    || k === 'error' || /^HTTP 5/.test(k) || k === 'HTTP 000';
+}
+
 /** Default bar a classified race answer must clear (0–10). Overridable. */
 export const RACE_MIN_SCORE = Number(process.env.OZ_RACE_MIN_SCORE || 6);
 
@@ -149,6 +187,9 @@ export function createRaceFeed(onDelta, onStatus, need) {
       }
     },
     onBack() {
+      // Late countable stragglers after ship used to paint "racing 4/2 back…"
+      // onto an already-idle thread (GET /threads/:id returns raw liveStatus).
+      if (settled || back >= need) return;
       back += 1;
       paintStatus();
     },

package/lib/models.js

@@ -1,4 +1,5 @@
 import { config } from './config.js';
+import { fetchHeaders } from './fetch.js';
 
 /** Same threshold as BIND_MIN_CHARS in hrr.js — kept local so this
  *  module stays importable without the wallet/rpc stack. */
@@ -53,7 +54,7 @@ let cache = { at: 0, ids: null };
 
 export async function zooModelIds() {
   if (cache.ids && Date.now() - cache.at < CATALOG_TTL_MS) return cache.ids;
-  const r = await fetch(`${config.apiBase}/v1/models`);
+  const r = await fetchHeaders(`${config.apiBase}/v1/models`);
   if (!r.ok) throw new Error(`model catalog fetch failed: HTTP ${r.status}`);
   const d = await r.json();
   const ids = (d.data || []).map((m) => m.id).filter(Boolean);

package/lib/pay.js

@@ -14,6 +14,7 @@ import {
   resolvePool, poolState, depositForShares, buildWrapInstructions, sendWrap,
 } from './wrap.js';
 import { applySubscriptionHeaders, loadSubscription, stripAuthorization } from './subscription.js';
+import { fetchHeaders } from './fetch.js';
 
 export class QuoteTooHighError extends Error {
   constructor(billedUsd, quote) {
@@ -339,7 +340,7 @@ export class PayClient {
     // there is no key, or if the gateway still answers 402.
     const sub = loadSubscription();
     if (sub?.key) init = { ...init, headers: applySubscriptionHeaders(init.headers, sub) };
-    const first = await fetch(url, init);
+    const first = await fetchHeaders(url, init);
     if (first.status !== 402) {
       return { response: first, paid: false, subscription: Boolean(sub?.key && first.ok) };
     }
@@ -400,7 +401,7 @@ export class PayClient {
       });
     }
     onStage?.('paying');
-    const response = await fetch(url, {
+    const response = await fetchHeaders(url, {
       ...init,
       headers: { ...stripAuthorization(init.headers || {}), 'X-PAYMENT': payment.header },
     });

package/lib/podagent.mjs

@@ -25,8 +25,10 @@ import { randomUUID } from 'node:crypto';
 import {
   formatPayStatus, startModelWait, readWithIdleTimeout, STREAM_IDLE_MS,
   createRaceFeed, pickRaceWinner, parseClassifyScore, RACE_MIN_SCORE,
-  isRaceCountable, raceLastShip,
+  isRaceCountable, raceLastShip, shouldRetryRaceArrival, raceFailKind,
+  summarizeRaceFailures,
 } from './livestatus.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);
@@ -278,9 +280,15 @@ export function adaptiveTopK(boundItems) {
   return Math.max(16, Math.min(256, Math.ceil(Math.sqrt(n) * 2)));
 }
 
-async function postChat(body, contextId, topK, onStatus) {
+async function postChat(body, contextId, topK, onStatus, signal) {
+  void contextId; // spill path: never send as x-hrr-context
   let r;
   for (let attempt = 0; attempt <= PAYMENT_RETRIES; attempt++) {
+    if (signal?.aborted) {
+      const err = new Error(signal.reason?.message || 'aborted');
+      err.name = 'AbortError';
+      throw err;
+    }
     r = await fetch(`${PROXY}/chat/completions`, {
       method: 'POST',
       headers: {
@@ -288,12 +296,16 @@ async function postChat(body, contextId, topK, onStatus) {
         // Only sent when we actually know the corpus size; without it the
         // gateway keeps its own default rather than getting a made-up number.
         ...(topK ? { 'x-hrr-top-k': String(topK) } : {}),
-        // real leCore memory for this thread, bound via POST /v1/hrr/bind — NOT
-        // a fabricated mechanism. Retrieval runs automatically once this header
-        // is set; nothing more for the model to invent or explain.
-        ...(contextId ? { 'x-hrr-context': contextId } : {}),
+        // Do NOT attach x-hrr-context. proxy.js maybeCacheCorpus bails
+        // (`if (req.headers['x-hrr-context']) return null`) so Claude CLI's
+        // bind-prefix / send-3/131-turns never ran for grokui. Tetris then
+        // shipped ~850k chars × race of 4 and every model failed in ~22s.
+        // Completions must hit the same sidecar spill path as `npx openzoo claude`.
+        // bindThread stays for other things; contextId is kept on the signature
+        // so brain / brainStream callers do not change.
       },
       body: JSON.stringify(body),
+      ...(signal ? { signal } : {}),
     });
     if (r.status !== 402 || attempt === PAYMENT_RETRIES) return r;
     // A 402 retry used to be silent — grokui sat on mute "…" for the whole
@@ -319,7 +331,7 @@ function withModelId(messages, model) {
     : m));
 }
 
-export async function brain(messages, contextId, modelOverride, topK) {
+export async function brain(messages, contextId, modelOverride, topK, signal) {
   // explicit plugins, not relying on the gateway's "inject when caller said
   // nothing" default — an explicit array is always respected as-is, so every
   // bot on every model actually has web search. max_tokens 900 was cutting
@@ -334,7 +346,7 @@ export async function brain(messages, contextId, modelOverride, topK) {
   messages = vision ? messages : stripImages(messages);
   const r = await postChat(
     { model, max_tokens: 4096, messages: withModelId(messages, model), plugins: [{ id: 'web' }] },
-    contextId, topK, undefined,
+    contextId, topK, undefined, signal,
   );
   const j = await r.json().catch(() => ({}));
   const content = j?.choices?.[0]?.message?.content;
@@ -375,19 +387,21 @@ async function brainContinue(messages, sofar, contextId, modelOverride, round) {
  *  callers that need to parse a directive out of the complete reply still can.
  *  onStatus(detail) is an optional second channel: paying / waiting on model /
  *  thinking, so a 20–40s settle is visibly alive instead of mute dots. */
-export async function brainStream(messages, onDelta, contextId, modelOverride, maxTokens, round = 0, topK = 0, onStatus) {
+export async function brainStream(messages, onDelta, contextId, modelOverride, maxTokens, round = 0, topK = 0, onStatus, signal) {
   const vision = hasImages(messages);
   const model = vision ? VISION_MODEL : (modelOverride || MODEL);
   messages = vision ? messages : stripImages(messages);
   const budget = maxTokens || MAX_TOKENS;
   const r = await postChat(
     { model, max_tokens: budget, messages: withModelId(messages, model), plugins: [{ id: 'web' }], stream: true },
-    contextId, topK, onStatus,
+    contextId, topK, onStatus, signal,
   );
   if (!r.ok || !r.body) {
     // fall back to the non-streaming path rather than fail outright
-    const content = await r.json().then((j) => j?.choices?.[0]?.message?.content).catch(() => undefined);
-    const text = content || (r.ok ? '' : await httpErrorNote(r.status));
+    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)));
     if (text) onDelta(text);
     return text;
   }
@@ -417,7 +431,7 @@ export async function brainStream(messages, onDelta, contextId, modelOverride, m
           return full + note;
         }
         onStatus?.('waiting on model…');
-        const fallback = await brain(messages, contextId, modelOverride, topK);
+        const fallback = await brain(messages, contextId, modelOverride, topK, signal);
         if (fallback) onDelta(fallback);
         return fallback || '(stream timed out — no tokens arrived)';
       }
@@ -465,7 +479,7 @@ export async function brainStream(messages, onDelta, contextId, modelOverride, m
   // reasoning model thinks the most. Retry ONCE with a bigger budget.
   if (!full && reasonedChars > 0 && !maxTokens) {
     onStatus?.('retrying…');
-    return brainStream(messages, onDelta, contextId, modelOverride, budget * 4, round, topK, onStatus);
+    return brainStream(messages, onDelta, contextId, modelOverride, budget * 4, round, topK, onStatus, signal);
   }
 
   // CUT OFF MID-ANSWER. finish_reason "length" means the model had more to say
@@ -564,8 +578,32 @@ const TIERS = {
     'qwen/qwen3.8-max',                  // 18
     'x-ai/grok-4.5',                     // 18
   ],
+  // Dedicated grok 4.6 band (tweeted as its own dial next to cheap/medium/expensive).
+  // One slug cannot fill a 4-wide race without replacement, so the pool is grok
+  // chat models with 4.6 first. No imagine / stt / tts / video.
+  'grok4.6': [
+    'x-ai/grok-4.6',
+    'x-ai/grok-4.5',
+    'x-ai/grok-4.3',
+    'x-ai/grok-4.20',
+  ],
 };
 export const TIER_NAMES = Object.keys(TIERS);
+export const TIER_ALIASES = {
+  grok: 'grok4.6',
+  'grok 4.6': 'grok4.6',
+  'grok-4.6': 'grok4.6',
+  'grok4.6': 'grok4.6',
+};
+export function normalizeTier(s) {
+  const raw = String(s || '').trim().toLowerCase();
+  if (TIER_NAMES.includes(raw)) return raw;
+  if (TIER_ALIASES[raw]) return TIER_ALIASES[raw];
+  const compact = raw.replace(/[\s_]/g, '');
+  if (TIER_NAMES.includes(compact)) return compact;
+  if (TIER_ALIASES[compact]) return TIER_ALIASES[compact];
+  return null;
+}
 
 let catalogCache = { at: 0, ids: null };
 async function servedIds() {
@@ -667,40 +705,68 @@ export async function brainRace(messages, onDelta, contextId, models, need = 1,
   let finished = 0;
   let release;
   const enough = new Promise((r) => { release = r; });
+  const raceAbort = new AbortController();
+  if (hooks.signal) {
+    if (hooks.signal.aborted) raceAbort.abort(hooks.signal.reason);
+    else hooks.signal.addEventListener('abort', () => raceAbort.abort(), { once: true });
+  }
+
+  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)),
+      });
+      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);
+    try { raceAbort.abort(); } catch { /* already */ }
     return out.text;
   };
 
   // Do not pass onStatus into each entrant — their "waiting on model…" would
   // clobber the race line. Race owns the status until a winner ships.
-  const attempts = list.map((m) => stream(messages, (chunk) => feed.onToken(m, chunk), contextId, m, maxTokens)
-    .then((text) => {
-      const raw = text == null ? '' : String(text);
-      const arrival = { model: m, text: raw };
-      arrivals.push(arrival);
-      if (isRaceCountable(arrival)) {
-        done.push(arrival);
-        feed.onBack();
-      } else {
-        feed.onFail(m);
+  // fetch-failed / empty / 5xx are retried ONCE on the same slot — tetris was
+  // shipping every-model-failed after a single ~22s fetch failed per racer.
+  const runOne = async (m) => {
+    let last = { model: m, text: '', error: 'empty body' };
+    for (let attempt = 0; attempt < 2; attempt++) {
+      if (raceAbort.signal.aborted && attempt > 0) break;
+      try {
+        const text = await stream(messages, (chunk) => feed.onToken(m, chunk), contextId, m, maxTokens, 0, 0, undefined, raceAbort.signal);
+        last = { model: m, text: text == null ? '' : String(text) };
+        if (isRaceCountable(last)) {
+          arrivals.push(last);
+          done.push(last);
+          feed.onBack();
+          return;
+        }
+      } catch (e) {
+        last = { model: m, text: '', error: e?.message || 'error' };
       }
-    })
-    .catch((e) => {
-      arrivals.push({ model: m, text: '', error: e?.message || 'error' });
-      feed.onFail(m);
-    })
-    .finally(() => {
-      finished += 1;
-      // Either we have what we asked for, or everyone is done and no more is
-      // coming — without the second condition a race where two of three fail
-      // would hang forever waiting for a K that can never arrive.
-      if (done.length >= want || finished === list.length) release();
-    }));
-  // Losers keep running; swallow their rejections so one cannot take the
-  // process down after the winner has already been returned.
+      if (!shouldRetryRaceArrival(last) || attempt === 1 || raceAbort.signal.aborted) break;
+    }
+    arrivals.push(last);
+    feed.onFail(m);
+  };
+
+  const attempts = list.map((m) => runOne(m).finally(() => {
+    finished += 1;
+    // Either we have what we asked for, or everyone is done and no more is
+    // coming — without the second condition a race where two of three fail
+    // would hang forever waiting for a K that can never arrive.
+    if (done.length >= want || finished === list.length) release();
+  }));
+  // Losers keep running until ship() aborts them; swallow rejections so one
+  // cannot take the process down after the winner has already been returned.
   for (const p of attempts) p.catch(() => {});
 
   await enough;

package/lib/proxy.js

@@ -360,7 +360,7 @@ async function spillTranscript(body, log, req, stats, extra = {}) {
   if (!msgs?.length) return null;
 
   // PATHS FIRST, BYTES LATER. The cut/length gates below used to run before
-  // filesForCorpus, so a short agent turn that Read a file never bound it �
+  // filesForCorpus, so a short agent turn that Read a file never bound it �
   // and when the extract itself returned empty, nothing logged. Collect
   // unconditionally, but only paths + cheap stat/mtime: a 2MB Read must not
   // stall this turn. readdir + readFile + bindCorpus run after we return,
@@ -486,14 +486,14 @@ async function spillTranscript(body, log, req, stats, extra = {}) {
   //
   // FILES RIDE THE BACKGROUND, NEVER THE CRITICAL PATH.
   //
-  // The FIRST bind of a session is necessarily synchronous � the request cannot
+  // The FIRST bind of a session is necessarily synchronous � the request cannot
   // go until the context_id exists, because it travels as x-hrr-context. Folding
   // file bytes into that bind put a 400KB upload in front of the caller's turn,
   // which is the cold-bind stall this whole exercise was meant to remove: the
   // bind endpoint measures 0.34-0.48s on a 613KB corpus, and that is 0.34-0.48s
   // the user waits before a single token appears.
   //
-  // Nothing recalls a file during the turn that read it � the model already has
+  // Nothing recalls a file during the turn that read it � the model already has
   // the tool result in its window. Files are only worth having bound for the
   // NEXT ask. So the conversation binds inline and the files are appended after
   // the fact, off the clock.
@@ -503,15 +503,15 @@ async function spillTranscript(body, log, req, stats, extra = {}) {
 
   // FILES BIND EVEN WHEN THE CONVERSATION IS TOO SMALL TO SPILL.
   //
-  // The threshold exists to stop us binding a two-line chat � it was never
+  // The threshold exists to stop us binding a two-line chat � it was never
   // meant to gate FILES. But bailing here skipped them entirely, so a fresh
   // session that reads a 200KB file bound nothing and scored 1.00x forever:
   // OBSERVED on a live session that read files all turn and never produced a
   // corpus, because its conversation stayed under the threshold the whole time.
   //
   // A file is worth binding on its own merit. So when the turns are too small
-  // to spill but files exist, bind the files anyway � in the background,
-  // against this session's context � and let this turn go unspilled. The corpus
+  // to spill but files exist, bind the files anyway � in the background,
+  // against this session's context � and let this turn go unspilled. The corpus
   // is then waiting for the next ask.
   if (corpus.length <= BIND_MIN_CHARS) {
     bindFilesInBackground('conversation under spill threshold, background');
@@ -560,7 +560,7 @@ async function spillTranscript(body, log, req, stats, extra = {}) {
     // Sidecar came back up: we still know the context_id and the accumulated
     // char count, but not the prior prefix string, so we cannot slice a delta.
     // Re-append the current prefix (some overlap is harmless) and keep the
-    // restored ledger � do not add corpus.length again.
+    // restored ledger � do not add corpus.length again.
     void bindCorpus(corpus, {
       appendTo: prior.contextId,
       onStage: (stage, info) => {
@@ -572,7 +572,7 @@ async function spillTranscript(body, log, req, stats, extra = {}) {
   } else if (prior && typeof prior.corpus === 'string' && corpus.startsWith(prior.corpus) && corpus.length > prior.corpus.length) {
     const delta = corpus.slice(prior.corpus.length);
     deltaChars = delta.length;
-    // FIRE AND FORGET. This delta is history for FUTURE turns � the answer
+    // FIRE AND FORGET. This delta is history for FUTURE turns � the answer
     // being generated right now is served from the tail plus what is already
     // bound, so waiting on the upload buys nothing and costs the user the
     // round trip on every single turn. The context id is already known, so
@@ -580,7 +580,7 @@ async function spillTranscript(body, log, req, stats, extra = {}) {
     //
     // The FIRST bind is deliberately NOT async: the request must carry
     // x-hrr-context, and that id does not exist until the bind returns. Firing
-    // that one off would send the opening turn with no context at all � a
+    // that one off would send the opening turn with no context at all � a
     // silently worse answer traded for a shorter pause, which is the wrong way
     // round.
     void bindCorpus(delta, {
@@ -598,7 +598,7 @@ async function spillTranscript(body, log, req, stats, extra = {}) {
       },
     });
   }
-  // CONVERSATION LEDGER � every successful bind AND append, not only when
+  // CONVERSATION LEDGER � every successful bind AND append, not only when
   // files exist. First bind initializes to the bound corpus size; each append
   // adds the delta; file bytes ride on top. This is what makes x-hrr-corpus-chars
   // the accumulated bound corpus instead of this-turn's prefix.
@@ -614,11 +614,11 @@ async function spillTranscript(body, log, req, stats, extra = {}) {
   // we just secured: this turn is already answerable without them, and the next
   // ask gets them for free. `boundFiles` already deduped by path:mtime, so this
   // uploads each version exactly once no matter how often the agent re-reads it.
-  // Read + readdir are inside setImmediate � they must not run before send().
+  // Read + readdir are inside setImmediate � they must not run before send().
   bindFilesInBackground('background', { appendTo: bind.contextId, asAppend: true });
   spillMemo.set(anchor, { corpus, contextId: bind.contextId, hash: bind.hash });
   if (spillMemo.size > 32) spillMemo.delete(spillMemo.keys().next().value);
-  // Count the tail that is actually forwarded after stub/trim � older
+  // Count the tail that is actually forwarded after stub/trim � older
   // continue-turn rounds after the ask may have been dropped, so
   // msgs.length - cut would keep lastSend growing with the raw pile.
   const sent = Math.max(0, stubbed.messages.length - cut);
@@ -787,7 +787,7 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
     saveSessionSpend({ spentUsd: sessionSpent, cogsUsd: sessionCogs, directUsd: sessionDirect, paidCalls });
   };
   if (restored.ok && (sessionSpent > 0 || paidCalls > 0)) {
-    say(`session restored: $${sessionSpent.toFixed(6)} � ${paidCalls} paid call${paidCalls === 1 ? '' : 's'}`);
+    say(`session restored: $${sessionSpent.toFixed(6)} � ${paidCalls} paid call${paidCalls === 1 ? '' : 's'}`);
   }
   process.on('exit', rememberSpend);
   const MARKUP = 3; // confirmed constant, see .claude/wiki.md "Margin needs a like-for-like denominator"
@@ -885,7 +885,10 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
     // whichever surface happens to be asking. Local-only, no auth needed:
     // it's a number, not a capability.
     if (req.method === 'GET' && (req.url || '').split('?')[0] === '/v1/session') {
-      await refreshCredit();
+      // NEVER await fly.dev. Serve last-known; a hung keep-alive on the same
+      // undici pool as brainRace used to wedge this handler (LISTEN up, HTTP 000).
+      // refreshCredit() is fire-and-forget so HUD "continue" cannot sit on HTTP 000.
+      refreshCredit().catch(() => {});
       refreshPrices();
       const money = walletMoney();
       res.writeHead(200, { 'content-type': 'application/json' });
@@ -901,8 +904,8 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
     // grokui error path, in particular) can print REAL funding instructions
     // inline instead of telling the user to go look somewhere else.
     if (req.method === 'GET' && (req.url || '').split('?')[0] === '/v1/wallet') {
-      await refreshCredit();
-      await refreshPrices();
+      refreshCredit().catch(() => {});
+      refreshPrices();
       const money = walletMoney();
       res.writeHead(200, { 'content-type': 'application/json' });
       res.end(JSON.stringify({
@@ -1025,8 +1028,8 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
           mcp: `${self.replace(/\/v1$/, '')}/mcp`,
           upstream: config.apiBase,
           payment: subscriptionPublicView().active
-            ? 'subscription key � no x402 � wallet/x402 remains the other method'
-            : 'x402 per request from the operator\'s local burner wallet � no API key, no account',
+            ? 'subscription key � no x402 � wallet/x402 remains the other method'
+            : 'x402 per request from the operator\'s local burner wallet � no API key, no account',
           auth: viaTunnel
             ? 'this public URL requires the oz_… bearer for paid endpoints; /v1/models and /v1/hrr/bind are free'
             : 'localhost is keyless',
@@ -1247,56 +1250,56 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         // (402 handshake behind a long Grok stream). Pin to a fast
         // non-reasoning catalog id and leave max_tokens alone. Real
         // Grok/DeepSeek chats (max_tokens 2000+ AND a long transcript)
-        // still get the 4000 floor � those still go blank without it.
-        // 0.48.75 missed grok nubs at max_tokens 128/2000 on a 1�2
-        // message body (~3� from the floor, no classifier log).
+        // still get the 4000 floor � those still go blank without it.
+        // 0.48.75 missed grok nubs at max_tokens 128/2000 on a 1�2
+        // message body (~3� from the floor, no classifier log).
         let ids = [];
         try { ids = await zooModelIds(); } catch { /* catalog miss: still skip the floor on a tiny classify */ }
         const policy = rewriteChatModel(parsed, ids, { bodyLen: bodyBuf.length });
         parsed = policy.parsed;
         if (policy.tiny) {
-          // `openzoo claude` starts us silent � `log` is a no-op then. say()
+          // `openzoo claude` starts us silent � `log` is a no-op then. say()
           // is the proxy.log channel and never the Claude Code TTY.
           say(`classifier tiny max_tokens=${Number(parsed?.max_tokens)} "${policy.from}" -> ${policy.to} (no reasoning floor)`);
         } else {
           // SAY WHETHER THE OVERRIDE IS ACTUALLY SET, and name it.
           //
           // This used to print "(OPENZOO_DEFAULT_MODEL overrides)" on EVERY
-          // rewrite whether or not the variable existed � a hint about a knob,
+          // rewrite whether or not the variable existed � a hint about a knob,
           // phrased as a statement about this request. It cost a real incident:
           // the proxy was restarted from a shell carrying
           // OPENZOO_DEFAULT_MODEL=deepseek/deepseek-v4-pro-0813, so every
           // claude-sonnet-5 ask was served by deepseek, and the log line looked
           // exactly the same as it always had. deepseek matches the reasoning
           // regex, so a 16-token safety classification became a 4,000-token
-          // reasoning generation � 11.5s, past the caller's timeout, and Claude
+          // reasoning generation � 11.5s, past the caller's timeout, and Claude
           // Code reported "claude-sonnet-5 is temporarily unavailable".
           // Tiny classify is pinned above and never reaches this path.
           if (policy.to && policy.to !== policy.from) {
             const forced = process.env.OPENZOO_DEFAULT_MODEL;
             log(forced
               ? `model "${policy.from}" -> FORCED to ${forced} by OPENZOO_DEFAULT_MODEL (nearest match would have been ${policy.to})`
-              : `model "${policy.from}" is not on the zoo � nearest match ${policy.to}`);
+              : `model "${policy.from}" is not on the zoo � nearest match ${policy.to}`);
           }
           // REASONING MODELS SPEND max_tokens ON THINKING FIRST.
           //
           // The budget covers hidden reasoning AND the visible answer, so a
           // caller that asks for 40 tokens because it wants a short answer often
-          // gets ZERO � the whole allowance went to reasoning and the completion
+          // gets ZERO � the whole allowance went to reasoning and the completion
           // truncated to an empty string. Measured across three families in one
           // day: deepseek returned 0 chars at 8k and was fine at 24k; grok-4.6
           // pinned ct at exactly its 16,000 budget with no visible output;
           // sonnet-5 truncated a 600-token file mid-function because Anthropic's
           // max_tokens covers thinking too.
           //
-          // An empty completion is not an error � it bills normally and renders
-          // as a blank reply � so this fails silently and looks like the retrieval
+          // An empty completion is not an error � it bills normally and renders
+          // as a blank reply � so this fails silently and looks like the retrieval
           // broke. It cost real debugging time tonight for exactly that reason.
           // Multiply the allowance for known reasoning families and let callers
           // keep asking for what they actually want back.
           //
           // A MULTIPLIER ALONE IS NOT ENOUGH. 4x on a caller's 40 is 160, which is
-          // still nothing for a model that thinks first � measured, 2 of 3 runs
+          // still nothing for a model that thinks first � measured, 2 of 3 runs
           // still returned empty at 160. Reasoning needs an absolute floor, not a
           // relative bump, so take whichever is larger.
           if (policy.raised) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openzoo",
-  "version": "0.48.97",
+  "version": "0.48.99",
   "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",