openzoo 0.48.92 → 0.48.96

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,
@@ -221,10 +221,12 @@ subtasks), you may instead reply with EXACTLY one line, no prose, using one of:
                                                      independent agent and give it a task
   SEND: <name> | <message>                          message an agent thread that already
                                                      exists (yours or one you spawned)
-  PING: <name>                                       one-line status: still working, or
-                                                       its last result
+  PING: <name>                                       wake that agent to take a turn now
+                                                       (* / all / everyone = the whole project).
+                                                       You get back "pinged, working" — that is
+                                                       an ack, not the child's result
   PEEK: <name>                                       a fuller look — its last few messages,
-                                                       not just the latest one
+                                                       not just the latest one. Read-only.
 You are given the result before your next line, so none of these block you — check back
 later if it's still working.
 
@@ -500,7 +502,7 @@ spawn/delegate/create agents AND no other bot has already done it this round, re
 EXACTLY one line, no prose, using one of:
   SPAWN: <short name> | <task for the new agent>   create a new thread with its own agent
   SEND: <name> | <message>                          message an existing agent thread
-  PING: <name>                                       one-line status, or its last result
+  PING: <name>                                       wake that agent (* / all = the project)
   PEEK: <name>                                       a fuller look at its last few messages
 
 You ALSO have real (sandboxed) filesystem access, scoped to THIS group's own directory —
@@ -661,6 +663,35 @@ const NUDGE = 'That reply announced work instead of doing it — no directive li
 const AUTO_CONTINUE = 'AUTO is still on — do not stop and do not ask the user to type continue. '
   + 'Emit the next directive now (RUN:/SPAWN:/SEND:/READ:/WRITE:/GLOB:/FETCH:/MCP:/SERVE:), '
   + 'or DONE: if the job is actually finished.';
+// PING used to be a read: last-line status, no turn. Idle children stayed idle
+// while the parent treated the dump as evidence they had acted. A ping is a
+// wake — the same harness continue AUTO already uses, unless a custom message
+// was given. Thinking threads are left alone; pendingRun stays on the human.
+let runTurnOverride = null;
+function setRunTurnForTest(fn) {
+  runTurnOverride = typeof fn === 'function' ? fn : null;
+}
+function kickTurn(threadId, userText, onEvent, images) {
+  // Default to emitToThread so a spawned/pinged kid streams when someone has
+  // that thread open. emitToThread is a no-op if nobody is watching.
+  const emit = onEvent === undefined ? (ev) => emitToThread(threadId, ev) : onEvent;
+  return (runTurnOverride || runTurn)(threadId, userText, emit, images);
+}
+function pingWakeText(extra) {
+  const msg = String(extra || '').trim();
+  // A restated spawn brief is not a nudge. MEASURED live: existing-SPAWN
+  // wrapped children in childKickoff({fresh:false}) → "CONTEXT REFRESH —
+  // you already exist" and they thought, then refused to redo the job.
+  if (!msg || /CONTEXT REFRESH|--- your specific job ---|ROOT ASK —/.test(msg)) return AUTO_CONTINUE;
+  return msg;
+}
+function pingCanWake(x) {
+  return Boolean(x) && !x.pendingRun && x.status !== 'thinking';
+}
+function wakeOnPing(x, extra) {
+  // Never childKickoff. Ping is a short continue, not a first-day re-brief.
+  kickTurn(x.id, pingWakeText(extra)).catch(() => {});
+}
 // Ceiling on subagents per thread. Spawning is fire-and-forget and each child
 // can spawn too, so without a count it is unbounded — MEASURED as 15+ threads
 // all named tetris-contract, every one of them a live agent making paid calls.
@@ -927,7 +958,7 @@ const SLASH_COMMANDS = [
   { name: '/memory', args: '[text|clear]', help: 'facts injected into every turn' },
   { name: '/sessions', args: '', help: 'list all threads' },
   { name: '/all', args: '<message>', help: 'send a message to every bot in this project' },
-  { name: '/ping', args: '', help: 'status of every bot in this project' },
+  { name: '/ping', args: '', help: 'wake idle bots below you to take a turn now' },
   { name: '/cron', args: '<mins> | <message>', help: 'repeat a message on a timer' },
   { name: '/crons', args: '', help: 'list timers  (/cron del <id> removes one)' },
   { name: '/dir', args: '<path>', help: 'set this thread’s working directory' },
@@ -1037,7 +1068,8 @@ async function handleSlash(task, t) {
       + '  SPAWN: <name> | <task>              a NEW subagent (names are unique —\n'
       + '                                      spawning an existing one sends to it)\n'
       + '  SEND: <name> | <msg>                more work for an EXISTING subagent\n'
-      + '  PING / PEEK                         reach or inspect another bot\n\n'
+      + '  PING: <name>                        wake that bot (* wakes the project)\n'
+      + '  PEEK: <name>                        read-only look at another bot\n\n'
       + 'READ, LS, GLOB, GREP, FETCH, PEEK and MCP run CONCURRENTLY when several\n'
       + 'appear in one reply — four files cost one round trip, not four.';
   }
@@ -1206,23 +1238,30 @@ 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(', ')}`;
   }
 
-  // Read the room without spending anything: who is working, who is blocked on
-  // an approval, what each said last.
+  // Wake the room. Used to be a free last-line dump — idle children stayed
+  // idle, and a parent reading "kid: <old reply>" thought they had acted.
+  // Empty extra is a nudge (AUTO_CONTINUE), not a cancel. Thinking stays
+  // thinking; pendingRun stays on the human. Same branch scope as /all.
   if (cmd === 'ping') {
-    // Same scoping as /all: your branch, not the whole project.
     const crew = subtreeOf(t.id, true);
     if (crew.length < 2) return 'You have no subagents yet.';
     return crew.map((x) => {
       const mark = x.id === t.id ? ' (here)' : '';
-      const last = x.history[x.history.length - 1];
-      return x.pendingRun ? `  ${x.name}${mark}: BLOCKED — waiting for your approval`
-        : x.status === 'thinking' ? `  ${x.name}${mark}: working`
-        : last ? `  ${x.name}${mark}: ${String(last.text).replace(/\s+/g, ' ').slice(0, 90)}`
-        : `  ${x.name}${mark}: nothing yet`;
+      if (x.id === t.id) {
+        const last = x.history[x.history.length - 1];
+        return x.pendingRun ? `  ${x.name}${mark}: BLOCKED — waiting for your approval`
+          : x.status === 'thinking' ? `  ${x.name}${mark}: working`
+          : last ? `  ${x.name}${mark}: ${String(last.text).replace(/\s+/g, ' ').slice(0, 90)}`
+          : `  ${x.name}${mark}: nothing yet`;
+      }
+      if (x.pendingRun) return `  ${x.name}${mark}: BLOCKED — waiting for your approval`;
+      if (x.status === 'thinking') return `  ${x.name}${mark}: working`;
+      wakeOnPing(x, arg);
+      return `  ${x.name}${mark}: pinged, working`;
     }).join('\n');
   }
 
@@ -1273,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();
@@ -1767,14 +1806,15 @@ async function tryDirective(reply, originId, onEvent) {
     const notes = [];
     for (const { name, task } of parsed) {
       const existing = findByName(name);
-      if (existing) { notes.push(`${name} already exists — sending it the task.`); made.push({ t: existing, task, fresh: false }); continue; }
+      if (existing) { notes.push(`${name} already exists — woke it to keep working.`); made.push({ t: existing, task, fresh: false }); continue; }
       const siblings = [...threads.values()].filter((x) => x.parent === originId).length;
       if (siblings >= SPAWN_MAX_CHILDREN) { notes.push(`Not spawning "${name}": already at ${SPAWN_MAX_CHILDREN} subagents.`); continue; }
       made.push({ t: newThread(name, originId), task, fresh: true });
     }
     // Every thread now exists, so spawnPosition sees the COMPLETE cohort.
     for (const { t: sub, task, fresh } of made) {
-      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);
     return [fresh.length ? `Spawned ${fresh.length} together (they can each see the full crew): ${fresh.join(', ')}` : '', ...notes]
@@ -1793,8 +1833,11 @@ async function tryDirective(reply, originId, onEvent) {
     // is what SEND already does.
     const existing = findByName(name);
     if (existing) {
-      runTurn(existing.id, childKickoff(threads.get(originId), existing.name, task, { fresh: false })).catch(() => {});
-      return `${name} already exists — sent it the task instead of spawning a duplicate.`;
+      // Repeat SPAWN is a wake, not a CONTEXT REFRESH. childKickoff({fresh:false})
+      // restates the original job and tells the child it already exists — MEASURED,
+      // the crew flipped to that preview, thought once, and sat.
+      wakeOnPing(existing);
+      return `${name} already exists — woke it to keep working.`;
     }
     // Storm guard. Fire-and-forget spawning is unbounded by construction: each
     // child can spawn, and nothing above it is counting.
@@ -1806,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.
@@ -1835,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
@@ -1847,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
@@ -1861,27 +1904,29 @@ async function tryDirective(reply, originId, onEvent) {
   const ping = pingAll.length === 1 ? [null, pingAll[0]] : null;
   if (ping) {
     const name = ping[1].trim();
-    // PING: * (or 'all' / 'project') reaches EVERY bot in this project.
+    // PING: * (or 'all' / 'project') WAKES every other bot in this project.
     // Coordinating a spawn tree by naming siblings one at a time is a chore
     // the parent should not have to do, and it cannot know who else exists.
+    // The return is an ack ("pinged, working"), not a last-line dump that
+    // lets the parent think the child already acted.
     if (/^(\*|all|project|everyone)$/i.test(name)) {
       const me = threads.get(originId);
       const root = me ? rootOf(me).rootId : null;
       const crew = [...threads.values()].filter((x) => x.id !== originId && rootOf(x).rootId === root);
       if (!crew.length) return 'No other bots in this project yet.';
       return crew.map((x) => {
-        const last = x.history[x.history.length - 1];
-        return x.pendingRun ? x.name + ': BLOCKED — waiting for approval'
-          : x.status === 'thinking' ? x.name + ': still working'
-          : last ? x.name + ': ' + String(last.text).slice(0, 200)
-          : x.name + ': no reply yet';
+        if (x.pendingRun) return x.name + ': BLOCKED — waiting for approval';
+        if (x.status === 'thinking') return x.name + ': still working';
+        wakeOnPing(x);
+        return x.name + ': pinged, working';
       }).join('\n');
     }
     const target = findByName(name);
-    const last = target?.history[target.history.length - 1];
-    return !target ? `No thread named "${name}".`
-      : target.status === 'thinking' ? `${name} is still working.`
-      : last ? `${name}: ${last.text}` : `${name} hasn't replied yet.`;
+    if (!target) return `No thread named "${name}".`;
+    if (target.pendingRun) return `${name}: BLOCKED — waiting for approval`;
+    if (target.status === 'thinking') return `${name} is still working.`;
+    wakeOnPing(target);
+    return `${name}: pinged, working`;
   }
   const peek = /^[ \t>*-]*PEEK:\s*(.+)/m.exec(reply);
   if (peek) {
@@ -2089,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(() => {});
@@ -2257,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;
@@ -2282,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 {
@@ -2343,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.
@@ -2368,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.
@@ -2379,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;
@@ -3121,12 +3172,9 @@ const APP_HTML = `<!doctype html>
   </div>
   <div id="walletOverlay" data-component="wallet-modal">
     <div id="walletBox">
-      <h3>Your wallet</h3>
-      <div class="wsub">Two ways to pay, side by side. Wallet/x402 stays. A card subscription sits next to it — not instead of it.</div>
-      <div class="wlanetitle">Wallet / x402</div>
-      <div class="wsub">This is <b>your</b> local burner on this machine (or this box). Keys stay in ~/.openzoo/wallet.json. It is not openzoo’s wallet, not a shared zoo account, not the model’s. You fund these deposit addresses; the app pays x402 per call from this wallet. Public addresses only — the UI never shows the key.</div>
-      <div id="walletBody">loading…</div>
-      <div class="wlane" id="subLane" data-component="subscribe-lane">
+      <h3>Pay with a card</h3>
+      <div class="wsub">Pay with a card. Basic, Pro, and Ultra are first. Wallet/x402 is the other option below — it stays; it is not the lead.</div>
+      <div id="subLane" data-component="subscribe-lane">
         <div class="wlanetitle">Subscribe with a card</div>
         <div class="wtag">Subscription key · no x402</div>
         <div class="wsub">Same plans as the public page. Checkout opens in the system browser — never an in-app Stripe window. After Stripe, this app polls the site’s key endpoint with the checkout session, or you paste the key from the success page.</div>
@@ -3142,6 +3190,11 @@ const APP_HTML = `<!doctype html>
         <div class="wnote" id="subNote"></div>
         <div class="wquiet"><a id="subPageLink" href="${SUBSCRIPTIONS_PAGE}" target="_blank" rel="noopener">Full subscriptions page</a></div>
       </div>
+      <div class="wlane" id="x402Lane" data-component="x402-lane">
+        <div class="wlanetitle">Wallet / x402</div>
+        <div class="wsub">This is <b>your</b> local burner on this machine (or this box). Keys stay in ~/.openzoo/wallet.json. It is not openzoo’s wallet, not a shared zoo account, not the model’s. You fund these deposit addresses; the app pays x402 per call from this wallet. Public addresses only — the UI never shows the key.</div>
+        <div id="walletBody">loading…</div>
+      </div>
     </div>
   </div>
   <div id="main">
@@ -3176,7 +3229,7 @@ const APP_HTML = `<!doctype html>
         </optgroup>
       </select>
       <button class="dial" id="walletBtn" data-component="wallet-open"
-              title="Wallet/x402 or subscribe with a card — deposit addresses, live balances, Stripe plans">wallet</button>
+              title="Pay with a card, or use wallet/x402">pay</button>
       <button class="icon-btn" id="reloadBtn" title="Restart grokui on this box">&#8635;</button>
       <button class="icon-btn" id="hudBtn">◎</button>
       </div>
@@ -3486,7 +3539,7 @@ const APP_HTML = `<!doctype html>
         // subagents without retyping — and pressing it addressed the WHOLE
         // project, cousins included. Now every thread with descendants gets
         // one, scoped to its own branch.
-        (t.kids ? '<button class="pingall trow-ping" data-testid="ping-all" title="Message all '
+        (t.kids ? '<button class="pingall trow-ping" data-testid="ping-all" title="Wake all '
           + t.kids + ' bot(s) below ' + escapeHtml(t.name) + '">\u21f2 ' + t.kids + '</button>' : '') +
         '<button class="tclose" title="Remove">✕</button>';
       row.addEventListener('click', () => {
@@ -3501,18 +3554,17 @@ const APP_HTML = `<!doctype html>
       if (pingBtn) {
         pingBtn.addEventListener('click', async (e) => {
           e.stopPropagation();
-          const msg = prompt('Send to all ' + t.kids + ' bot(s) below ' + t.name + ':');
-          // Empty is a cancel — sending "" would spend a paid turn on every
-          // bot in the branch for nothing.
-          if (msg === null || !msg.trim()) return;
+          // Default click = wake with the harness continue. window.prompt is
+          // missing or blocked in Electron, so a modal here silently no-op'd
+          // the only UI path that tried to reach the crew. /all still sends
+          // exact text; ping is "poke them to work".
           pingBtn.disabled = true;
           const was = pingBtn.textContent;
           pingBtn.textContent = '…';
           try {
-            // Routed through THIS thread, so /all scopes to its own subtree.
             await fetch(API + '/drive', { method: 'POST', headers: { 'content-type': 'application/json' },
-              body: JSON.stringify({ threadId: t.id, task: '/all ' + msg.trim() }) });
-            pingBtn.textContent = 'sent';
+              body: JSON.stringify({ threadId: t.id, task: '/ping' }) });
+            pingBtn.textContent = 'pinged';
           } catch (err) { pingBtn.textContent = 'failed'; }
           setTimeout(() => { pingBtn.disabled = false; pingBtn.textContent = was; }, 1500);
           await loadThreads();
@@ -3623,7 +3675,7 @@ const APP_HTML = `<!doctype html>
     if (!w || (!w.solana && !w.evm && w.creditUsd == null)) {
       const p = document.createElement('div');
       p.className = 'wnote wempty';
-      p.textContent = 'Could not reach the local openzoo proxy on :8402. It may still be starting — try again in a few seconds. You can still subscribe with a card below.';
+      p.textContent = 'Could not reach the local openzoo proxy on :8402. It may still be starting — try again in a few seconds. You can still subscribe with a card above.';
       walletBody.appendChild(p);
       renderSubLane(w && w.subscription ? w.subscription : null);
       return;
@@ -3665,7 +3717,7 @@ const APP_HTML = `<!doctype html>
     note.textContent = subOn
       ? ('Wallet is optional while a subscription is active. ' + (w.funding || ''))
       : (w.funded === false
-        ? 'This wallet is EMPTY — wallet/x402 calls will fail with HTTP 402 until you fund the addresses above, or subscribe with a card below. ' + (w.funding || '')
+        ? 'This wallet is EMPTY — wallet/x402 calls will fail with HTTP 402 until you fund the addresses above, or subscribe with a card at the top. ' + (w.funding || '')
         : (w.funding || ''));
     if (w.funded === false && !subOn) note.classList.add('wempty');
     if (note.textContent.trim()) walletBody.appendChild(note);
@@ -3832,8 +3884,9 @@ const APP_HTML = `<!doctype html>
     if (e.key === 'Enter') { e.preventDefault(); savePastedSub(); }
   });
   // First launch: if the burner is empty AND there is no subscription, open
-  // the wallet once so they see addresses — and the card lane. localStorage
-  // so a funded session, a saved key, or a dismiss does not keep popping it.
+  // the pay modal once so they see card plans first — and burner addresses
+  // below. localStorage so a funded session, a saved key, or a dismiss does
+  // not keep popping it.
   (async function maybeOpenWalletOnce() {
     if (localStorage.getItem('openzoo.wallet.seen')) return;
     for (let i = 0; i < 8; i++) {
@@ -4449,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 */ };
@@ -5128,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';
@@ -5139,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;
     }
@@ -5237,4 +5293,6 @@ server.listen(PORT, BIND, () => console.log(`[grokui] http://${BIND === '0.0.0.0
 export {
   tryDirective, ensureWorkspacePort, isPreviewableRel, previewAck, workspaceFileUrl,
   parseRun, looksLikeMcpAsBash, stripThinkTags, safeResolveIn, inDir, listDir,
+  handleSlash, newThread, setRunTurnForTest, AUTO_CONTINUE, pingWakeText, pingCanWake,
+  childKickoff,
 };

package/lib/livestatus.js

@@ -28,6 +28,134 @@ 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…`;
+}
+
+/** Real answers count toward X. Empty and HTTP/pay/timeout notes do not. */
+export function isRaceCountable(text) {
+  const s = String(text || '').trim();
+  if (!s) return false;
+  return !/^\((?:upstream error|request failed|payment failed|rate limited|stream timed out|stream stalled)/i.test(s);
+}
+
+function shortModel(id) {
+  const s = String(id || '');
+  if (!s) return '';
+  return s.includes('/') ? s.split('/').pop() : s;
+}
+
+/**
+ * Last completion that arrived, even if empty-ish or error-y.
+ * Never blank: synthesize a visible error when nobody produced text.
+ */
+export function raceLastShip(arrivals) {
+  const list = Array.isArray(arrivals) ? arrivals : [];
+  const last = list[list.length - 1];
+  if (!last) return { model: '', text: '(race: every model failed — no reply)', error: true };
+  const raw = String(last.text || '');
+  if (raw.trim()) return { ...last, text: raw };
+  const who = shortModel(last.model) || 'model';
+  if (last.error) return { ...last, text: `(${who} failed: ${last.error})`, error: true };
+  return { ...last, text: `(${who} returned nothing)`, 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 model failed — no reply)';
+      // 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,65 @@ 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), ship the last
+ * completion that arrived — even if empty-ish or error-y. If nobody produced
+ * any text, surface a real error in the bubble. 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);
+      arrivals.push({ model: m, text: raw });
+      if (isRaceCountable(raw)) {
+        done.push({ model: m, text: raw });
+        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 +703,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 stay in arrivals
+  // so we can still ship the last one if X never fills.
   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.92",
+  "version": "0.48.96",
   "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",