openzoo 0.49.0 → 0.49.1

package/lib/grokui.mjs

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

package/package.json

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