openzoo 0.48.94 → 0.48.97

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 } from './podagent.mjs';
-import { peekDirectiveStatus, STALE_THINKING_MS } from './livestatus.js';
+import { peekDirectiveStatus, formatRaceStatus, STALE_THINKING_MS } from './livestatus.js';
 import { creditBalance } from './info.js';
 import {
   SUBSCRIPTIONS_PAGE,
@@ -672,7 +672,10 @@ function setRunTurnForTest(fn) {
   runTurnOverride = typeof fn === 'function' ? fn : null;
 }
 function kickTurn(threadId, userText, onEvent, images) {
-  return (runTurnOverride || runTurn)(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.
+  const emit = onEvent === undefined ? (ev) => emitToThread(threadId, ev) : onEvent;
+  return (runTurnOverride || runTurn)(threadId, userText, emit, images);
 }
 function pingWakeText(extra) {
   const msg = String(extra || '').trim();
@@ -1235,7 +1238,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) runTurn(x.id, arg).catch(() => {});
+    for (const x of crew) kickTurn(x.id, arg).catch(() => {});
     return `Sent down your branch to ${crew.length} bot(s): ${crew.map((x) => x.name).join(', ')}`;
   }
 
@@ -1309,7 +1312,7 @@ setInterval(() => {
       if (c.nextAt > now) continue;
       c.nextAt = now + c.everyMin * 60000;
       saveThreads();
-      runTurn(t.id, c.text).catch(() => {});
+      kickTurn(t.id, c.text).catch(() => {});
     }
   }
 }, 15000).unref();
@@ -1810,7 +1813,7 @@ async function tryDirective(reply, originId, onEvent) {
     }
     // Every thread now exists, so spawnPosition sees the COMPLETE cohort.
     for (const { t: sub, task, fresh } of made) {
-      if (fresh) runTurn(sub.id, childKickoff(parent, sub.name, task, { fresh })).catch(() => {});
+      if (fresh) kickTurn(sub.id, childKickoff(parent, sub.name, task, { fresh })).catch(() => {});
       else wakeOnPing(sub);
     }
     const fresh = made.filter((m) => m.fresh).map((m) => m.t.name);
@@ -1846,7 +1849,7 @@ async function tryDirective(reply, originId, onEvent) {
     }
     const sub = newThread(name, originId);
     // The child gets the ORIGINATING brief plus its own job — see spawnBrief.
-    runTurn(sub.id, childKickoff(threads.get(originId), name, task)).catch(() => {}); // fire and forget
+    kickTurn(sub.id, childKickoff(threads.get(originId), name, task)).catch(() => {}); // fire and forget
     return `Spawned ${name} — working on it.`;
   }
   // SEND TO A NAME THAT DOES NOT EXIST YET *SPAWNS* IT.
@@ -1875,7 +1878,7 @@ async function tryDirective(reply, originId, onEvent) {
     const msg = sendM[2].trim();
     const target = findByName(name);
     if (target) {
-      runTurn(target.id, childKickoff(threads.get(originId), target.name, msg, { fresh: false })).catch(() => {});
+      kickTurn(target.id, childKickoff(threads.get(originId), target.name, msg, { fresh: false })).catch(() => {});
       return `Messaged ${name}.`;
     }
     // The SAME storm guard SPAWN uses — promoting a SEND must not be a way
@@ -1887,7 +1890,7 @@ async function tryDirective(reply, originId, onEvent) {
         + `(limit ${SPAWN_MAX_CHILDREN}). Reuse one with  SEND: <existing name> | <task>.`;
     }
     const sub = newThread(name, originId);
-    runTurn(sub.id, childKickoff(threads.get(originId), name, msg)).catch(() => {});
+    kickTurn(sub.id, childKickoff(threads.get(originId), name, msg)).catch(() => {});
     return `${name} did not exist — spawned it with that message as its task.`;
   }
   // PING had the same anchor bug — no `m`, so a PING after any preamble (or
@@ -2131,7 +2134,7 @@ async function tryDirective(reply, originId, onEvent) {
       const root = rootOf(t).rootId;
       const crew = [...threads.values()].filter((x) => x.id !== t.id && rootOf(x).rootId === root);
       for (const x of crew) {
-        runTurn(x.id, `[${t.name} finished] ${peek}\n`
+        kickTurn(x.id, `[${t.name} finished] ${peek}\n`
           + `(${t.todos.length - left}/${t.todos.length} of its goals done. `
           + `This is a status peek — do NOT redo this work, and do not reply unless it changes yours.)`)
           .catch(() => {});
@@ -2299,11 +2302,11 @@ async function mcpDirective(url, tool, args) {
 
 // onEvent (optional) gets live progress for whoever's actually watching this
 // call: {type:'start',name,color} when a bot begins its turn, {type:'status',
-// detail} while paying / waiting / walking tools, {type:'delta',name,color,
-// delta} per streamed token, {type:'final',name,color,text} once its full
-// reply (or directive ack) is settled. Background turns — a SPAWNed
-// subagent nobody's looking at yet — run with onEvent omitted and just use
-// the plain non-streaming brain(), which is cheaper when nothing renders it.
+// detail} while paying / waiting / racing / walking tools, {type:'delta',name,
+// color,delta} per streamed token (replace:true swaps the bubble once),
+// {type:'final',name,color,text} once its full reply (or directive ack) is
+// settled. Background turns go through kickTurn → emitToThread, which is a
+// no-op if nobody has the thread open.
 async function runTurn(threadId, userText, onEvent, images) {
   const t = threads.get(threadId);
   if (!t) return;
@@ -2324,7 +2327,9 @@ async function runTurn(threadId, userText, onEvent, images) {
   t.status = 'thinking';
   t.thinkingAt = Date.now();
   t.lastDeltaAt = Date.now();
-  t.liveStatus = 'waiting on model…';
+  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…';
   let chained = false;
   let parked = false;
   try {
@@ -2385,7 +2390,7 @@ async function runTurn(threadId, userText, onEvent, images) {
   }
   t.messages.push({ role: 'user', content: contentFor(userText, images) });
   let reply = '';
-  paint({ type: 'start', name: t.name, color: t.color, detail: 'waiting on model…' });
+  paint({ type: 'start', name: t.name, color: t.color, detail: t.liveStatus || 'waiting on model…' });
   // Transient: the nudge is appended for THIS call only and never pushed into
   // t.messages, so it can't accumulate across a chained auto run or get bound
   // into the thread's context.
@@ -2410,7 +2415,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) => {
-    const emit = (delta) => paint({ type: 'delta', name: t.name, color: t.color, delta });
+    const emit = (delta, meta) => paint({
+      type: 'delta', name: t.name, color: t.color, delta,
+      ...(meta?.replace ? { replace: true } : {}),
+      ...(meta?.model ? { model: meta.model } : {}),
+    });
     const emitStatus = (detail) => paint({ type: 'status', name: t.name, color: t.color, detail });
     // Retrieval breadth scales with the PROJECT's corpus, not this thread's —
     // the holobrain is shared at the root, so that is the pool being searched.
@@ -2421,10 +2430,10 @@ async function runTurn(threadId, userText, onEvent, images) {
       // need = how many must come BACK before judging. need 1 is a plain
       // first-past-the-post race; need N waits for all of them. The point of
       // the middle (2 of 3) is a judged answer without the slowest entrant
-      // setting the latency.
+      // 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);
-      emitStatus('waiting on model…');
-      return (await brainRace(callMsgs, emit, t.contextId, models, need)).trim();
+      return (await brainRace(callMsgs, emit, t.contextId, models, need, undefined, emitStatus)).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;
@@ -4493,7 +4502,10 @@ const APP_HTML = `<!doctype html>
       try { ev = JSON.parse(e.data); } catch { return; }
       if (ev.type === 'start') { streamBuf = ''; streamStatus = ev.detail || 'waiting on model…'; paintStream(); }
       else if (ev.type === 'status') { streamStatus = ev.detail || streamStatus; paintStream(); }
-      else if (ev.type === 'delta') { streamBuf += ev.delta || ''; paintStream(); }
+      else if (ev.type === 'delta') {
+        streamBuf = ev.replace ? (ev.delta || '') : streamBuf + (ev.delta || '');
+        paintStream();
+      }
       else if (ev.type === 'final' || ev.type === 'run-pending') { streamBuf = ''; streamStatus = ''; render(); }
     };
     es.onerror = () => { /* EventSource retries; the 1.2s poll is the backstop */ };
@@ -5172,7 +5184,7 @@ const server = http.createServer((req, res) => {
         saveThreads();
         res.writeHead(200, { 'content-type': 'application/json' });
         res.end('{"ok":true}');
-        runTurn(t.id, '(you denied running that command)').catch(() => {});
+        kickTurn(t.id, '(you denied running that command)').catch(() => {});
         return;
       }
       entry.runStatus = 'running';
@@ -5183,7 +5195,7 @@ const server = http.createServer((req, res) => {
         entry.runStatus = 'done';
         entry.runOutput = output;
         saveThreads();
-        runTurn(t.id, `(command output)\n${output}`).catch(() => {});
+        kickTurn(t.id, `(command output)\n${output}`).catch(() => {});
       });
       return;
     }

package/lib/livestatus.js

@@ -28,6 +28,143 @@ export function formatPayStatus(attempt = 0) {
   return Number(attempt) > 0 ? 'waiting on x402…' : 'paying…';
 }
 
+/** 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);
+  return `racing ${b}/${n} back…`;
+}
+
+/** Race-level failure when no countable answer exists. Never a single model name. */
+export const RACE_EVERY_FAILED = '(race: every model failed — no reply)';
+
+const RACE_HTTP_NOTE = /^\((?:upstream error|request failed|payment failed|rate limited|stream timed out|stream stalled)/i;
+const RACE_MODEL_FAILED = /^\([^)]+ (?:failed:|returned nothing)/i;
+const RACE_FETCH_FAILED = /^(?:typeerror:\s*)?fetch failed$/i;
+
+/**
+ * Real answers count toward X.
+ * Empty, HTTP/pay/timeout notes, TypeError `fetch failed`, `(model failed: …)`,
+ * and any arrival with `.error` do not — those racers are abandoned.
+ * Accepts a string or `{ text, error }`.
+ */
+export function isRaceCountable(textOrArrival) {
+  const arrival = textOrArrival && typeof textOrArrival === 'object' && !Array.isArray(textOrArrival)
+    ? textOrArrival
+    : { text: textOrArrival };
+  if (arrival.error) return false;
+  const s = String(arrival.text || '').trim();
+  if (!s) return false;
+  if (RACE_FETCH_FAILED.test(s)) return false;
+  if (RACE_HTTP_NOTE.test(s)) return false;
+  if (RACE_MODEL_FAILED.test(s)) return false;
+  return true;
+}
+
+/**
+ * Fallback when X never fills: one race-level error, not `(one-model failed: …)`.
+ * Failed arrivals are abandoned, not shipped as the assistant message.
+ */
+export function raceLastShip(arrivals) {
+  const list = Array.isArray(arrivals) ? arrivals : [];
+  const last = [...list].reverse().find((a) => isRaceCountable(a));
+  if (last) return { ...last, text: String(last.text) };
+  return { model: '', text: RACE_EVERY_FAILED, error: true };
+}
+
+/** Default bar a classified race answer must clear (0–10). Overridable. */
+export const RACE_MIN_SCORE = Number(process.env.OZ_RACE_MIN_SCORE || 6);
+
+/**
+ * Parse a cheap classify reply into a 0–10 score.
+ * Prefers `SCORE 7` / `SCORE: 7`; falls back to a lone 0–10.
+ * Unparseable → 0 (does not clear the bar).
+ */
+export function parseClassifyScore(text) {
+  const s = String(text || '');
+  const tagged = /SCORE\s*[:=]?\s*(-?\d+(?:\.\d+)?)/i.exec(s);
+  const lone = tagged || /\b(10|[0-9])(?:\s*\/\s*10)?\b/.exec(s);
+  if (!lone) return 0;
+  const n = Number(lone[1]);
+  if (!Number.isFinite(n)) return 0;
+  return Math.max(0, Math.min(10, n));
+}
+
+/**
+ * Pick a winner among the first-X-back candidates after they have been scored.
+ * Passing = score >= minScore. Highest score wins; a tie is returned as
+ * `reason: 'tie'` so the caller can pairwise-break it. If nobody clears the
+ * bar, the last of the X is accepted — never blank.
+ */
+export function pickRaceWinner(cands, minScore = RACE_MIN_SCORE) {
+  const list = Array.isArray(cands) ? cands.filter(Boolean) : [];
+  if (!list.length) return { winner: null, reason: 'empty', tied: [] };
+  const passing = list.filter((c) => (Number(c.score) || 0) >= minScore);
+  if (!passing.length) {
+    return { winner: list[list.length - 1], reason: 'fallback-last', tied: [] };
+  }
+  let max = -Infinity;
+  for (const c of passing) {
+    const sc = Number(c.score) || 0;
+    if (sc > max) max = sc;
+  }
+  const tied = passing.filter((c) => (Number(c.score) || 0) === max);
+  if (tied.length === 1) return { winner: tied[0], reason: 'score', tied };
+  return { winner: null, reason: 'tie', tied };
+}
+
+/**
+ * Live race bubble: stream the fastest still-alive entrant, swap once if the
+ * winner is someone else. `onDelta(text, { replace, model })`.
+ */
+export function createRaceFeed(onDelta, onStatus, need) {
+  let live = null;
+  let settled = false;
+  let back = 0;
+  const buf = new Map();
+  const dead = new Set();
+  const paintStatus = () => { onStatus?.(formatRaceStatus(back, need)); };
+  return {
+    start() { paintStatus(); },
+    liveModel() { return live; },
+    onToken(model, chunk) {
+      if (settled || chunk == null || chunk === '') return;
+      buf.set(model, (buf.get(model) || '') + chunk);
+      if (!live) {
+        live = model;
+        onDelta?.(chunk, { model });
+        return;
+      }
+      if (live === model) onDelta?.(chunk, { model });
+    },
+    onFail(model) {
+      dead.add(model);
+      if (settled || live !== model) return;
+      const next = [...buf.entries()].find(([m, t]) => m !== model && t && !dead.has(m));
+      if (next) {
+        live = next[0];
+        onDelta?.(next[1], { replace: true, model: live });
+      } else {
+        live = null;
+      }
+    },
+    onBack() {
+      back += 1;
+      paintStatus();
+    },
+    settle(winner) {
+      settled = true;
+      const text = String(winner?.text || '').trim()
+        ? winner.text
+        : RACE_EVERY_FAILED;
+      // Live stream already showing this answer — keep going, do not re-dump.
+      if (winner?.model && live === winner.model && !winner.error) return;
+      live = winner?.model || live;
+      onDelta?.(text, { replace: true, model: winner?.model });
+    },
+  };
+}
+
 export function peekDirectiveStatus(reply, runCmd) {
   if (runCmd) return `RUN: ${clipStatusArg(runCmd)}`;
   const raw = String(reply || '');

package/lib/podagent.mjs

@@ -24,6 +24,8 @@ import { appendFileSync } from 'node:fs';
 import { randomUUID } from 'node:crypto';
 import {
   formatPayStatus, startModelWait, readWithIdleTimeout, STREAM_IDLE_MS,
+  createRaceFeed, pickRaceWinner, parseClassifyScore, RACE_MIN_SCORE,
+  isRaceCountable, raceLastShip,
 } from './livestatus.js';
 
 const PORTS = (process.env.OZ_AGENT_PORTS || '1337,6080,1340,6081')
@@ -630,26 +632,66 @@ export async function tierModels(tier, n = 1, random = false) {
  * count toward K — otherwise the fastest model to FAIL would decide the race,
  * the exact bug this exists to fix.
  *
- * Streaming is deliberately not forwarded while the race runs: nobody knows who
- * is winning until they finish, and interleaving deltas from three models would
- * render as noise. The winner's text is emitted whole.
+ * Live tokens: the fastest still-alive entrant is forwarded into onDelta as
+ * they arrive (not swallowed). When a winner is picked, if it is that live
+ * stream the bubble keeps going; if it is someone else the bubble is replaced
+ * once (`onDelta(text, { replace: true })`), not left on mute dots.
+ *
+ * After the first X land, a cheap classify call scores each of those X
+ * (correctness, completeness, actually did the asked thing — a RUN:/DONE:
+ * directive is success, not a flaw). Highest score that clears the bar wins;
+ * a tie is pairwise-broken. If nobody clears, the last of the X is shipped
+ * anyway. If X never fills (every entrant empty/5xx/fetch-failed), ship a
+ * race-level error — never a single model's `(name failed: fetch failed)` as
+ * if it won. Never blank, never hang.
  *
  * 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.
+ *
+ * `hooks` is for tests: `{ stream, classify, pairwise, minScore }`.
  */
-export async function brainRace(messages, onDelta, contextId, models, need = 1, maxTokens) {
+export async function brainRace(messages, onDelta, contextId, models, need = 1, maxTokens, onStatus, hooks = {}) {
+  const stream = hooks.stream || brainStream;
+  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);
-  if (list.length < 2) return brainStream(messages, onDelta, contextId, list[0], maxTokens);
+  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));
 
+  const feed = createRaceFeed(onDelta, onStatus, want);
+  feed.start();
+
   const done = [];
+  const arrivals = [];
   let finished = 0;
   let release;
   const enough = new Promise((r) => { release = r; });
 
-  const attempts = list.map((m) => brainStream(messages, () => {}, contextId, m, maxTokens)
-    .then((text) => { if (text && text.trim()) done.push({ model: m, text }); })
-    .catch(() => { /* one entrant dying is not the race dying */ })
+  const ship = (cand) => {
+    const out = cand && String(cand.text || '').trim() ? cand : raceLastShip(arrivals);
+    feed.settle(out);
+    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);
+      }
+    })
+    .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
@@ -662,58 +704,79 @@ export async function brainRace(messages, onDelta, contextId, models, need = 1,
   for (const p of attempts) p.catch(() => {});
 
   await enough;
-  // Completion order, so this really is the first K back — not the first K
-  // launched.
+  // Completion order, so this really is the first X back — not the first X
+  // launched. A slow 3rd never enters this set. Empty/5xx/fetch-failed stay
+  // in arrivals only so an all-fail race can ship one race-level error.
   const cands = done.slice(0, want);
-  if (!cands.length) return '';
-  // Nothing to compare — do not spend a judging call to rubber-stamp one answer.
-  if (cands.length === 1) { onDelta(cands[0].text); return cands[0].text; }
+  if (!cands.length) return ship(raceLastShip(arrivals));
+  // One real answer — nothing to compare. Ship it; do not spend a classify
+  // call to rubber-stamp the only candidate.
+  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();
+    // Malformed verdict / all equally bad → last finished of the tie, not empty.
+    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));
+}
+
+function raceQuestion(messages) {
+  const asked = [...messages].reverse().find((m) => m.role === 'user')?.content;
+  return typeof asked === 'string' ? asked : '(see candidates)';
+}
 
-  const winner = await judge(messages, cands);
-  onDelta(winner.text);
-  return winner.text;
+/**
+ * Cheap structured score of ONE finished answer vs the question.
+ * This is grokui's own classify call — not OpenRouter's async log-tag
+ * Classifiers beta, which does not pick winners.
+ */
+async function classifyRaceAnswer(messages, cand) {
+  const prompt = 'Score this answer to one question from 0 to 10.\n\n'
+    + 'QUESTION:\n' + String(raceQuestion(messages)).slice(0, 4000) + '\n\n'
+    + 'ANSWER:\n' + String(cand?.text || '').slice(0, 6000) + '\n\n'
+    + 'Judge on: correctness first, then completeness, then whether it actually did what was asked '
+    + '(a directive like RUN: or DONE: on one line is the correct format here, not a flaw). '
+    + 'Ignore length and confidence of tone.\n'
+    + 'Reply with exactly: SCORE <n>';
+  const verdict = await brainStream(
+    [{ role: 'user', content: prompt }], () => {}, undefined, JUDGE_MODEL, 24,
+  );
+  return parseClassifyScore(verdict);
 }
 
 /**
- * Pick the best of several finished answers with a small model.
- *
- * BLIND, as A/B/C/D. A judge told "this one is Claude and this one is a 4B
- * llama" is being handed the answer and will take it, which would turn the
- * whole thing into an expensive way to re-pick the tier's first entry.
- *
- * Cheap on purpose: reading finished replies and comparing them against a
- * question is a far easier task than answering it, and paying frontier prices
- * to referee frontier models would roughly double the cost of the expensive
- * tier for no measured gain.
+ * Pairwise break among same-score passers. Blind A/B/C so the model names
+ * cannot leak the answer. Last of the tied set if the call dies.
  */
-async function judge(messages, cands) {
-  const letters = cands.map((_, i) => String.fromCharCode(65 + i));
-  // The question, not the transcript: the judge needs to know what was ASKED,
-  // and a full history would cost more to judge than the turn cost to answer.
-  const asked = [...messages].reverse().find((m) => m.role === 'user')?.content;
-  const question = typeof asked === 'string' ? asked : '(see candidates)';
+async function pairwiseTied(messages, tied) {
+  const letters = tied.map((_, i) => String.fromCharCode(65 + i));
   const prompt = 'You are judging answers to one question. Pick the single best one.\n\n'
-    + 'QUESTION:\n' + String(question).slice(0, 4000) + '\n\n'
-    + cands.map((c, i) => 'ANSWER ' + letters[i] + ':\n' + c.text.slice(0, 6000)).join('\n\n')
+    + 'QUESTION:\n' + String(raceQuestion(messages)).slice(0, 4000) + '\n\n'
+    + tied.map((c, i) => 'ANSWER ' + letters[i] + ':\n' + String(c.text || '').slice(0, 6000)).join('\n\n')
     + '\n\nJudge on: correctness first, then completeness, then whether it actually did what was asked '
     + '(a directive like RUN: or DONE: on one line is the correct format here, not a flaw). '
     + 'Ignore length and confidence of tone.\n'
     + 'Reply with ONE letter and nothing else: ' + letters.join(' or ') + '.';
   try {
     const verdict = await brainStream([{ role: 'user', content: prompt }], () => {}, undefined, JUDGE_MODEL, 8);
-    // First in-range letter anywhere in the reply. A judge that ignores "one
-    // letter and nothing else" and writes "The best is B." still counts, which
-    // is most of them.
     const hit = String(verdict).toUpperCase().split('').find((ch) => {
       const n = ch.charCodeAt(0) - 65;
-      return n >= 0 && n < cands.length;
+      return n >= 0 && n < tied.length;
     });
-    if (hit) return cands[hit.charCodeAt(0) - 65];
+    if (hit) return tied[hit.charCodeAt(0) - 65];
   } catch { /* fall through */ }
-  // A dead or delisted judge must not lose the answers. Falling back to the
-  // first finisher degrades this to "fastest wins" — worse than judged, far
-  // better than empty.
-  return cands[0];
+  return tied[tied.length - 1];
 }
 
 const RACE_MAX = Number(process.env.OZ_RACE_MAX || 4);

package/package.json

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