openzoo 0.49.6 → 0.49.7

package/lib/boxes.js

@@ -77,7 +77,7 @@ const ENTRYPOINT = [
   // its HTTP port mappings). The app is read-only at runtime; mutable state
   // lives in /root/.openzoo.
   + 'until OPENZOO_BIND=0.0.0.0 node /opt/openzoo/bin/openzoo.js >> /var/log/openzoo/proxy.log 2>&1; do echo "proxy exited, restarting" >> /var/log/openzoo/proxy.log; sleep 2; done & '
-  + 'until OZ_GROKUI_BIND=0.0.0.0 OZ_GROKUI_PORT=4173 node /opt/grokui/grokui.mjs >> /var/log/openzoo/grokui.log 2>&1; do echo "grokui exited, restarting" >> /var/log/openzoo/grokui.log; sleep 2; done & '
+  + 'until OZ_GROKUI_BIND=0.0.0.0 OZ_GROKUI_PORT=4173 node /opt/openzoo/lib/grokui.mjs >> /var/log/openzoo/grokui.log 2>&1; do echo "grokui exited, restarting" >> /var/log/openzoo/grokui.log; sleep 2; done & '
   // the capture agent answers the ports Grok Bot expects a Cursor sandbox on,
   // logging the protocol we do not yet speak (see lib/podagent.mjs)
   + 'if [ -n "$OZ_PODAGENT_B64" ]; then printf %s "$OZ_PODAGENT_B64" | base64 -d > /opt/podagent.mjs; node /opt/podagent.mjs > /var/log/openzoo/agent.log 2>&1 & fi; '

package/lib/models.js

@@ -323,10 +323,24 @@ export function isTinyClassify(body, bodyLen) {
   return messages.length <= CLASSIFY_MAX_MSGS && len < CLASSIFY_MAX_BODY;
 }
 
+/**
+ * Ids that must never serve Claude Code / grokui AUTO's tiny yes/no classify.
+ * REASONING_MODEL_RE is the thinking floor; HEAVY_RE is the flagship set
+ * (opus/pro/max/…). opus-5 is openzoo's default session model and does NOT
+ * match the reasoning regex, so a catalog that lists opus before flash — or
+ * lists only opus + grok — used to pick opus as "first non-reasoner". That
+ * classify is a 402 handshake on a big model; AUTO's timeout then hard-blocks
+ * Bash instead of prompting.
+ */
+function isSlowClassifier(id) {
+  const s = String(id || '');
+  return REASONING_MODEL_RE.test(s) || HEAVY_RE.test(s);
+}
+
 /**
  * Fast non-reasoning id that is actually on the zoo. Prefer an explicit
  * OPENZOO_CLASSIFIER_MODEL, then flash, then haiku, then the first catalog
- * id that does not match the reasoning regex.
+ * id that is neither a reasoner nor a heavy/flagship (opus/pro/max/…).
  */
 export function pickClassifierModel(ids, preferred = process.env.OPENZOO_CLASSIFIER_MODEL) {
   if (!Array.isArray(ids) || !ids.length) return null;
@@ -334,7 +348,7 @@ export function pickClassifierModel(ids, preferred = process.env.OPENZOO_CLASSIF
   for (const id of CLASSIFIER_PREFS) {
     if (ids.includes(id)) return id;
   }
-  return ids.find((id) => !REASONING_MODEL_RE.test(id)) || null;
+  return ids.find((id) => !isSlowClassifier(id)) || null;
 }
 
 /**
@@ -362,14 +376,22 @@ export function raiseReasoningMaxTokens(parsed, env = process.env) {
  * Model + max_tokens policy for one chat body.
  *
  * Tiny classify: pin to a fast non-reasoning catalog id, leave max_tokens
- * alone, ignore OPENZOO_DEFAULT_MODEL. Everything else: resolveModel (which
- * honours the default) then the reasoning floor.
+ * alone, ignore OPENZOO_DEFAULT_MODEL. Never fall back to `from` when that
+ * id is a reasoner or a heavy/flagship (the zoo default is opus-5). A
+ * catalog miss or an opus-only list used to keep the classify on opus-5
+ * and AUTO hard-blocked Bash. Everything else: resolveModel (which honours
+ * the default) then the reasoning floor.
  */
 export function rewriteChatModel(parsed, ids, { bodyLen } = {}) {
   const from = parsed?.model;
   const len = bodyLen ?? (parsed == null ? 0 : Buffer.byteLength(JSON.stringify(parsed)));
   if (isTinyClassify(parsed, len)) {
-    const to = (typeof from === 'string' && pickClassifierModel(ids)) || from;
+    const picked = pickClassifierModel(ids);
+    // pickClassifierModel returns null on an empty catalog or a zoo that
+    // only lists reasoners/heavies. `(picked) || from` left those on
+    // anthropic/claude-opus-5 (openzoo's default). Pin to flash instead —
+    // never ship a classify body AUTO would time out and hard-block on.
+    const to = picked || (typeof from === 'string' && !isSlowClassifier(from) ? from : CLASSIFIER_PREFS[0]);
     return {
       parsed: (to && to !== from) ? { ...parsed, model: to } : parsed,
       tiny: true,

package/lib/proxy.js

@@ -14,9 +14,11 @@ import { evmTokenBalance } from './evm.js';
 import { bindCorpus, contextCacheDisabled, BIND_MIN_CHARS } from './hrr.js';
 import {
   loadBoundChars, noteCorpusLedger, filesForCorpus, readFilesForCorpus, boundAbsFromKeys,
-  createSpillStats, corpusCharsForSend, applySpillCut, msgText, hudDollarX,
+  createSpillStats, corpusCharsForSend, msgText, hudDollarX,
   spillPricedLine,
   planConversationBind, rememberSpillMemo, SPILL_CONTENT_ANCHOR_CHARS,
+  corpusRecall,
+  decideChatSpill, isOneShotCorpusAsk,
 } from './spill.js';
 import { rewritablePath, augmentModelList, ALIAS_IDS, rewriteChatModel, zooModelIds, CLASSIFY_MAX_TOKENS } from './models.js';
 import { forgetContext } from './contexts.js';
@@ -431,40 +433,61 @@ async function spillTranscript(body, log, req, stats, extra = {}) {
   // in process memory so this request recuts when the green x is under 10.
   // No restart. OPENZOO_ADAPT=0 freezes the env defaults. The ask always
   // stays; we never drop below 2 real user/assistant turns to delete it.
+  //
+  // 1-model AND raced grokui AUTO both land here (same POST /chat/completions
+  // door). The old `msgs.length < 6` bail skipped fat 1-model hops � a 40k
+  // command-output turn with 4�5 messages never bound, so spent?direct.
+  // decideChatSpill is the shared gate: oversized ? bind prefix + system/tail
+  // + x-hrr-context; small ? passthrough. Race fields do not change it.
   const knownLedger = (sessionKey && spillMemo.get(sessionKey))
     || (sessionKey && sessionLedger.get(sessionKey))
     || null;
   const knownChars = knownLedger?.contextId
     ? (boundChars.get(knownLedger.contextId) || 0)
     : 0;
-  const adapted = applySpillCut(msgs, {
+  const decision = decideChatSpill(body, {
     corpusChars: knownChars,
     boundAbs: previouslyBoundAbs,
+    recall: corpusRecall(typeof knownLedger?.corpus === 'string' ? knownLedger.corpus : ''),
     log,
     persist: true,
     dollarX: extra.dollarX ?? hudDollarX(stats || {}),
     lastSend: extra.lastSend,
+    minPrefixChars: BIND_MIN_CHARS,
   });
-  if (adapted.cut <= adapted.firstSpillable) {
+  if (decision.mode === 'passthrough') {
+    bindFilesInBackground(decision.reason === 'no-cut'
+      ? 'no severable cut, files only'
+      : 'conversation under spill threshold, background');
+    return null;
+  }
+  if (decision.mode === 'stub-only') {
     bindFilesInBackground('no severable cut, files only');
     // Still forward stubbed/trimmed bodies so an un-severable storm is not
     // shipped at full size just because cutTranscript could not move.
-    if (adapted.stubbed?.dropped || adapted.stubbed?.stubbed) {
-      return {
-        body: Buffer.from(JSON.stringify({ ...body, messages: adapted.stubbed.messages })),
-        corpus: '',
-        reused: false,
-        savedBytes: 0,
-        sent: adapted.stubbed.messages.length,
-        msgs: msgs.length,
-      };
-    }
-    return null;
+    return {
+      body: Buffer.from(JSON.stringify({ ...body, messages: decision.forwarded })),
+      corpus: '',
+      reused: false,
+      savedBytes: 0,
+      sent: decision.forwarded.length,
+      msgs: msgs.length,
+    };
+  }
+  // oneshot is handled in maybeCacheCorpus; if we reach it here, bind the
+  // extracted corpus the same way as a transcript prefix.
+  if (decision.mode === 'oneshot' && !decision.adapted) {
+    decision.adapted = {
+      cut: msgs.length - 1,
+      firstSpillable: Math.max(0, msgs.findIndex((m) => m?.role !== 'system')),
+      stubbed: { messages: decision.forwarded, stubbed: 0, dropped: 0 },
+    };
   }
+  const adapted = decision.adapted;
   const { cut, firstSpillable } = adapted;
   const stubbed = adapted.stubbed;
 
-  const head = msgs.slice(0, firstSpillable);     // system block, always kept
+  const head = decision.head.length ? decision.head : msgs.slice(0, firstSpillable);     // system block, always kept
   // EVERY FILE THE AGENT TOUCHED, AT FULL SIZE.
   //
   // The saving ratio is corpus/sent, so on a fresh session — where the corpus
@@ -493,7 +516,8 @@ async function spillTranscript(body, log, req, stats, extra = {}) {
   // 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 they append after the conversation bind completes.
-  const turns = msgs.slice(firstSpillable, cut).map(msgText).filter(Boolean).join('\n\n');
+  const turns = decision.prefix
+    || msgs.slice(firstSpillable, cut).map(msgText).filter(Boolean).join('\n\n');
   const corpus = turns;
   if (!sessionKey) sessionKey = corpus.slice(0, SPILL_CONTENT_ANCHOR_CHARS);
 
@@ -704,7 +728,10 @@ async function spillTranscript(body, log, req, stats, extra = {}) {
   const topK = Math.max(4, Math.min(12, Math.round(budget / 320)));
 
   return {
-    body: Buffer.from(JSON.stringify({ ...body, messages: [...head, ...stubbed.messages.slice(cut)] })),
+    body: Buffer.from(JSON.stringify({
+      ...body,
+      messages: decision.forwarded || [...head, ...stubbed.messages.slice(cut)],
+    })),
     topK,
     contextId: bind.contextId,
     hash: bind.hash,
@@ -740,10 +767,10 @@ async function maybeCacheCorpus(req, bodyBuf, log, stats, extra = {}) {
   // the ask verbatim. Anything else (an agent transcript) falls through to the
   // transcript spill, which used to be a silent no-op.
   const last = msgs[msgs.length - 1];
-  const oneShot = typeof last?.content === 'string'
-    && last.content.length > BIND_MIN_CHARS
-    && last.content.lastIndexOf('\n\n') >= BIND_MIN_CHARS;
-  if (!oneShot) return spillTranscript(body, log, req, stats, extra);
+  // Same gate decideChatSpill uses � 1-model and race share it. zoo_ask
+  // stays on the corpus+question bind; everything else (including grokui
+  // AUTO, raced or not) falls through to spillTranscript ? decideChatSpill.
+  if (!isOneShotCorpusAsk(msgs, BIND_MIN_CHARS)) return spillTranscript(body, log, req, stats, extra);
   const cut = last.content.lastIndexOf('\n\n');
   const corpus = last.content.slice(0, cut);
   const ask = last.content.slice(cut + 2).trim();
@@ -933,7 +960,13 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       refreshPrices();
       const money = walletMoney();
       res.writeHead(200, { 'content-type': 'application/json' });
+      // Same package.json the startup banner reads � grokui-app refuses to
+      // attach to a leftover :8402 whose version is older than it shipped with.
+      const { version } = JSON.parse(
+        readFileSync(new URL('../package.json', import.meta.url), 'utf8'),
+      );
       res.end(JSON.stringify({
+        version,
         spentUsd: sessionSpent, cogsUsd: sessionCogs, directUsd: sessionDirect, paidCalls,
         creditUsd, chainUsd: money.chainUsd, lastQuoteUsd,
         subscription: subscriptionPublicView(),

package/lib/spill.js

@@ -552,6 +552,15 @@ export function hudDollarX({
 /** Tool result larger than this is "fat" — stub it in the forwarded tail. */
 export const FAT_TOOL_CHARS = 400;
 
+/**
+ * Over-budget forwarded-tail shrink (SHRINK_OVER). When the tail exceeds
+ * this many chars (or the caller `budget`), oldest tool_results are
+ * considered for `[bound]` stubs. A stub is emitted only if HRR recall
+ * actually returns overlapping bytes for that item — `boundFiles` /
+ * `boundAbs` is not proof.
+ */
+export const SHRINK_OVER = 6000;
+
 /**
  * Last-round bodies under this floor stay even after a follow-up ask
  * (0.48.77: a 461-byte bound Read must remain visible). Older rounds use
@@ -667,6 +676,84 @@ function toolContentLength(content) {
   return 0;
 }
 
+function toolContentText(content) {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content.map((b) => (typeof b === 'string' ? b : String(b?.text ?? b?.content ?? ''))).join('');
+  }
+  if (content && typeof content === 'object') return JSON.stringify(content);
+  return content == null ? '' : String(content);
+}
+
+/** Normalize a recall hook result to text. Empty means a miss. */
+export function recallText(got) {
+  if (got == null) return '';
+  if (typeof got === 'string') return got;
+  if (typeof Buffer !== 'undefined' && Buffer.isBuffer(got)) return got.toString('utf8');
+  if (typeof got === 'object') {
+    if (typeof got.text === 'string') return got.text;
+    if (typeof got.content === 'string') return got.content;
+    if (typeof got.bytes === 'string') return got.bytes;
+    if (typeof Buffer !== 'undefined' && Buffer.isBuffer(got.bytes)) return got.bytes.toString('utf8');
+  }
+  return '';
+}
+
+/** True when recalled text is non-empty and overlaps the original body. */
+export function recallOverlapsBody(recalled, body) {
+  const a = recallText(recalled);
+  const b = toolContentText(body);
+  if (!a || !b) return false;
+  if (b.includes(a) || a.includes(b)) return true;
+  const n = Math.min(32, a.length, b.length);
+  if (n < 1) return false;
+  for (let i = 0; i + n <= a.length; i += Math.max(1, Math.floor(n / 2))) {
+    if (b.includes(a.slice(i, i + n))) return true;
+  }
+  return false;
+}
+
+/**
+ * Probe `recall` for this tool_result / file. True only when the hook
+ * actually produced overlapping bytes — not when we merely think the
+ * path is bound.
+ */
+export function recallReturnedBytes(recall, item = {}) {
+  if (typeof recall !== 'function') return false;
+  let got;
+  try {
+    const content = toolContentText(item.content);
+    got = recall({
+      id: item.id,
+      paths: item.paths || [],
+      content,
+      query: item.query || (Array.isArray(item.paths) && item.paths[0]) || content.slice(0, 80),
+    });
+  } catch {
+    return false;
+  }
+  return recallOverlapsBody(got, item.content);
+}
+
+/**
+ * Local recall over already-bound corpus text. Hard-proof stand-in when a
+ * live HRR probe is not available: the exact bytes must be in the corpus
+ * AND the probe must return a non-empty overlapping slice.
+ */
+export function corpusRecall(corpus) {
+  const text = typeof corpus === 'string' ? corpus : '';
+  return (item = {}) => {
+    if (!text) return '';
+    const body = toolContentText(item.content);
+    const snippet = body.length >= 16 ? body.slice(0, 64) : body;
+    if (snippet && text.includes(snippet)) {
+      const i = text.indexOf(snippet);
+      return text.slice(i, i + Math.min(Math.max(body.length, snippet.length), 8192));
+    }
+    return '';
+  };
+}
+
 function resolveBoundPath(raw, cwd, boundAbs) {
   if (!boundAbs?.size) return null;
   const t = typeof raw === 'string' ? raw.trim() : '';
@@ -679,10 +766,17 @@ function resolveBoundPath(raw, cwd, boundAbs) {
 
 /**
  * After a file is bound, drop its tool_result / file body from the forwarded
- * tail. Keep the path and a short marker. The model already has the bytes in
- * the bound corpus via recall; shipping them again makes sent ≈ corpus and
- * the gateway's `counterfactualTokens > promptTokens` gate barely fires
- * (live: 5MB filebind, lastSend 13/107, savingX 1.22 instead of ~7x).
+ * tail. Keep the path and a short marker. Shipping those bytes again makes
+ * sent ≈ corpus and the gateway's `counterfactualTokens > promptTokens`
+ * gate barely fires (live: 5MB filebind, lastSend 13/107, savingX 1.22
+ * instead of ~7x).
+ *
+ * A `[bound]` marker is a promise that HRR recall can return those bytes.
+ * `boundAbs` / `boundFiles` only means we think we bound the path — that
+ * is not proof. On the SHRINK_OVER path (tail over `budget`), and whenever
+ * a `recall` hook is installed on a budgeted tail, stub only if recall
+ * actually returns non-empty overlapping content. Prefer the original body
+ * over a lying stub (context missing, file not in corpus, recall miss).
  *
  * Cheap rewrite — no disk I/O. First-read results (not yet in boundAbs) and
  * non-file tool output stay verbatim UNLESS `aggressive` / `stubMore` or a
@@ -728,6 +822,9 @@ export function stubBoundFileResults(msgs, {
   // assistant(tool_calls)+results chain. Ignored when the tail is severable.
   keepTail = null,
   fatChars = FAT_TOOL_CHARS,
+  // (query) => bytes. SHRINK_OVER [bound] stubs require a non-empty
+  // overlapping hit. boundFiles alone is not enough.
+  recall = null,
 } = {}) {
   const absSet = boundAbs || boundAbsFromKeys(boundFiles);
   const wantBudget = budget != null && Number.isFinite(Number(budget));
@@ -816,6 +913,29 @@ export function stubBoundFileResults(msgs, {
     return false;
   };
 
+  const recallCache = new Map();
+  const probeRecall = (id, content) => {
+    const key = id || toolContentText(content);
+    if (recallCache.has(key)) return recallCache.get(key);
+    const ok = recallReturnedBytes(recall, {
+      id,
+      content,
+      paths: idPaths.get(id) || [],
+    });
+    recallCache.set(key, ok);
+    return ok;
+  };
+
+  const allowBoundStub = (id, content, { overBudget = false } = {}) => {
+    // SHRINK_OVER leftovers always need real recall bytes (fail closed
+    // when no hook is installed). When a recall hook is installed on a
+    // budgeted tail, every [bound] claim uses the same gate.
+    if (overBudget || (wantBudget && typeof recall === 'function')) {
+      return probeRecall(id, content);
+    }
+    return true;
+  };
+
   let stubbed = 0;
   let dropped = 0;
   let messages = msgs;
@@ -849,6 +969,7 @@ export function stubBoundFileResults(msgs, {
     if (m.role === 'tool') {
       const n = toolContentLength(m.content);
       if (!shouldStubBody(m.tool_call_id, n) || isStubText(m.content)) return m;
+      if (!allowBoundStub(m.tool_call_id, m.content)) return m;
       dropped += n;
       stubbed += 1;
       return { ...m, content: stubFor(m.tool_call_id, n) };
@@ -882,6 +1003,7 @@ export function stubBoundFileResults(msgs, {
       if (b?.type !== 'tool_result') return b;
       const n = toolContentLength(b.content);
       if (!shouldStubBody(b.tool_use_id, n) || isStubText(b.content)) return b;
+      if (!allowBoundStub(b.tool_use_id, b.content)) return b;
       dropped += n;
       stubbed += 1;
       changed = true;
@@ -890,11 +1012,12 @@ export function stubBoundFileResults(msgs, {
     return changed ? { ...next, content: blocks } : next;
   });
 
-  // Byte budget wins inside a tool chain. cutTranscript cannot move tailStart
-  // past assistant(tool_calls) / role:tool (pairing 400s the provider), so a
-  // 300-result storm used to ride in at ~728k after file-only stubs. Stub
-  // bodies first, then fat tool_call JSON; if still over, drop older pairs.
-  // Never drop the ask. Never orphan a remaining tool_result.
+  // SHRINK_OVER: byte budget wins inside a tool chain. cutTranscript cannot
+  // move tailStart past assistant(tool_calls) / role:tool (pairing 400s the
+  // provider), so a 300-result storm used to ride in at ~728k after file-only
+  // stubs. Stub bodies first, then fat tool_call JSON; if still over, drop
+  // older pairs. Never drop the ask. Never orphan a remaining tool_result.
+  // Never write `[bound]` unless recall returned those bytes.
   if (wantBudget) {
     const cap = Number(budget);
     let used = sliceChars(messages, fromIndex);
@@ -908,6 +1031,7 @@ export function stubBoundFileResults(msgs, {
           if (isStubText(m.content)) continue;
           const n = toolContentLength(m.content);
           if (!shouldStubBody(m.tool_call_id, n, { overBudget: true })) continue;
+          if (!allowBoundStub(m.tool_call_id, m.content, { overBudget: true })) continue;
           const stub = stubFor(m.tool_call_id, n);
           if (stub.length >= n) continue;
           used = used - n + stub.length;
@@ -941,6 +1065,7 @@ export function stubBoundFileResults(msgs, {
           if (b?.type !== 'tool_result' || used <= cap || isStubText(b.content)) return b;
           const n = toolContentLength(b.content);
           if (!shouldStubBody(b.tool_use_id, n, { overBudget: true })) return b;
+          if (!allowBoundStub(b.tool_use_id, b.content, { overBudget: true })) return b;
           const stub = stubFor(b.tool_use_id, n);
           if (stub.length >= n) return b;
           used = used - n + stub.length;
@@ -984,7 +1109,7 @@ export const LAST_SEND_TIGHTEN = 24;
 export const KNOB_DEFAULTS = Object.freeze({
   keepTail: 8,
   minTurns: 6,
-  budget: 6000,
+  budget: SHRINK_OVER,
   stubMore: false,
 });
 
@@ -1397,6 +1522,8 @@ export function cutTranscript(msgs, knobs = {}) {
   const minTurns = Math.max(2, k.minTurns);
   const budget = k.budget;
 
+  const lastUser = lastUserAskIndex(msgs, firstSpillable);
+
   let cut = -1;
   for (let i = msgs.length - keepTail; i > firstSpillable; i--) {
     if (isSeverable(msgs, i, firstSpillable)) { cut = i; break; }
@@ -1407,7 +1534,7 @@ export function cutTranscript(msgs, knobs = {}) {
     }
   }
   if (cut <= firstSpillable) {
-    return { cut: -1, firstSpillable, lastUser: lastUserAskIndex(msgs, firstSpillable), knobs: k };
+    return { cut: -1, firstSpillable, lastUser, knobs: k };
   }
 
   // Only moves the cut at a severable index. A current-turn tool storm
@@ -1415,27 +1542,44 @@ export function cutTranscript(msgs, knobs = {}) {
   // index inside the chain, so this walk is a no-op — the byte budget is
   // applied by stubbing bodies in stubBoundFileResults, not by orphaning
   // a tool_result.
+  //
+  // When the overflow IS severable (grokui text hops: a fat previous
+  // command output sitting just before the current ask), start the tail
+  // AFTER that message so the live window is actually bounded. Starting
+  // AT the overflowing index left the fat hop in the forwarded body —
+  // spent≈direct on 1-model AUTO even after a cut existed.
   let tailStart = cut;
   {
     let used = 0;
     for (let i = msgs.length - 1; i >= cut; i--) {
       used += msgText(msgs[i]).length;
-      if (used > budget && isSeverable(msgs, i, firstSpillable)) { tailStart = i; break; }
+      if (used <= budget) continue;
+      const after = i + 1;
+      // Plain user/assistant hops only. Jumping after a tool_result would
+      // drop the current tool chain from the tail (orphans / lost pairing);
+      // those storms stay in-window and get stubbed.
+      const overflow = msgs[i];
+      const plainHop = overflow?.role === 'user' || (overflow?.role === 'assistant' && !toolCallIds(overflow).length);
+      if (plainHop && lastUser >= 0 && after <= lastUser && after > firstSpillable
+          && isSeverable(msgs, after, firstSpillable)) {
+        tailStart = after;
+        break;
+      }
+      if (isSeverable(msgs, i, firstSpillable)) { tailStart = i; break; }
     }
   }
   if (tailStart > cut) cut = tailStart;
 
-  const lastUser = lastUserAskIndex(msgs, firstSpillable);
-
-  // minTurns may still size the tail on a long thread. If walking earlier
-  // would empty the bind prefix (the old firstSpillable+1 fallback), keep a
-  // non-empty prefix and allow fewer than minTurns in the tail. On a short
-  // thread that cannot satisfy minTurns at all, pin the last ask so early
-  // user/assistant turns bind instead of riding in the forwarded tail.
+  // minTurns may still size the tail on a long thread, but never past the
+  // byte budget (that pulled fat 1-model hops back so sent≈unspilled).
+  // If walking earlier would empty the bind prefix, keep a non-empty prefix
+  // and allow fewer than minTurns. On a short thread that cannot satisfy
+  // minTurns at all, pin the last ask so early turns bind.
   if (countRealTurns(msgs, cut) < minTurns) {
     let moved = false;
     for (let i = cut - 1; i > firstSpillable; i--) {
       if (isSeverable(msgs, i, firstSpillable) && countRealTurns(msgs, i) >= minTurns) {
+        if (sliceChars(msgs, i) > budget) break;
         cut = i;
         moved = true;
         break;
@@ -1450,11 +1594,13 @@ export function cutTranscript(msgs, knobs = {}) {
 
   // 2-real-turn floor protects the last user ask: never drop it, and expand
   // the tail to two turns on a LONG thread. Do not steal the first
-  // user+assistant pair from the prefix just to pad a short tail.
+  // user+assistant pair from the prefix just to pad a short tail, and do
+  // not expand past the byte budget (that re-imported fat 1-model hops).
   if (lastUser > firstSpillable && countRealTurns(msgs, cut) < 2) {
     for (let i = cut - 1; i > firstSpillable; i--) {
       if (!isSeverable(msgs, i, firstSpillable) || countRealTurns(msgs, i) < 2) continue;
       if (countRealTurns(msgs, firstSpillable, i) < 2) continue;
+      if (sliceChars(msgs, i) > budget) break;
       cut = i;
       break;
     }
@@ -1588,6 +1734,7 @@ function stubForCut(msgs, cut, opts) {
     aggressive: Boolean(opts.aggressive),
     budget: opts.budget,
     keepTail: opts.keepTail,
+    recall: opts.recall,
   });
 }
 
@@ -1611,6 +1758,7 @@ export function applySpillCut(msgs, {
   home,
   dollarX,
   lastSend,
+  recall,
 } = {}) {
   const persistOpts = { persist, file, home };
   let k = sanitizeKnobs(knobs || getLiveKnobs(persistOpts));
@@ -1631,7 +1779,7 @@ export function applySpillCut(msgs, {
     // 300-result storm is not forwarded at full size.
     const stubFrom = plan.firstSpillable >= 0 ? plan.firstSpillable : 0;
     let stubbed = stubForCut(msgs, stubFrom, {
-      boundFiles, boundAbs, cwd, aggressive: k.stubMore, budget: k.budget, keepTail: k.keepTail,
+      boundFiles, boundAbs, cwd, aggressive: k.stubMore, budget: k.budget, keepTail: k.keepTail, recall,
     });
     let sentChars = sliceChars(stubbed.messages, stubFrom);
     const corpus = Math.max(Number(corpusChars) || 0, sentChars);
@@ -1651,7 +1799,7 @@ export function applySpillCut(msgs, {
       action = decision.action;
       if (decision.recut) {
         stubbed = stubForCut(msgs, stubFrom, {
-          boundFiles, boundAbs, cwd, aggressive: k.stubMore, budget: k.budget, keepTail: k.keepTail,
+          boundFiles, boundAbs, cwd, aggressive: k.stubMore, budget: k.budget, keepTail: k.keepTail, recall,
         });
         sentChars = sliceChars(stubbed.messages, stubFrom);
         ratio = spillRatio(corpus, sentChars);
@@ -1677,7 +1825,7 @@ export function applySpillCut(msgs, {
   };
 
   let stubbed = stubForCut(msgs, plan.cut, {
-    boundFiles, boundAbs, cwd, aggressive: k.stubMore, budget: k.budget, keepTail: k.keepTail,
+    boundFiles, boundAbs, cwd, aggressive: k.stubMore, budget: k.budget, keepTail: k.keepTail, recall,
   });
   let stats = measure(plan.cut, stubbed, k);
   let action = 'hold';
@@ -1698,7 +1846,7 @@ export function applySpillCut(msgs, {
       plan = cutTranscript(msgs, k);
       if (plan.cut > plan.firstSpillable) {
         stubbed = stubForCut(msgs, plan.cut, {
-          boundFiles, boundAbs, cwd, aggressive: k.stubMore, budget: k.budget, keepTail: k.keepTail,
+          boundFiles, boundAbs, cwd, aggressive: k.stubMore, budget: k.budget, keepTail: k.keepTail, recall,
         });
         stats = measure(plan.cut, stubbed, k);
       }
@@ -1721,6 +1869,119 @@ export function applySpillCut(msgs, {
   };
 }
 
+/**
+ * Same threshold hrr.js BIND_MIN_CHARS uses. Kept here so the 1-model /
+ * raced AUTO decision can be tested without standing up the bind client.
+ */
+export const SPILL_MIN_PREFIX_CHARS = Number(process.env.OPENZOO_CONTEXT_MIN_CHARS || 16384);
+
+/**
+ * zoo_ask / chat-surface shape: one huge final string ending in `\n\n<ask>`.
+ * Agent transcripts (Claude Code, grokui) never look like this.
+ */
+export function isOneShotCorpusAsk(msgs, minChars = SPILL_MIN_PREFIX_CHARS) {
+  if (!Array.isArray(msgs) || !msgs.length) return false;
+  const last = msgs[msgs.length - 1];
+  if (typeof last?.content !== 'string') return false;
+  if (last.content.length <= minChars) return false;
+  if (last.content.lastIndexOf('\n\n') < minChars) return false;
+  const ask = last.content.slice(last.content.lastIndexOf('\n\n') + 2).trim();
+  return Boolean(ask && ask.length <= 8000);
+}
+
+function emptySpillDecision(msgs, reason) {
+  return {
+    mode: 'passthrough',
+    reason,
+    setHrrContext: false,
+    forwarded: msgs,
+    prefix: '',
+    head: [],
+    tail: msgs,
+    sentChars: sliceChars(msgs),
+    unspilledChars: sliceChars(msgs),
+  };
+}
+
+/**
+ * THE spill/bind/forward gate. 1-model grokui and raced grokui AUTO both
+ * POST /chat/completions through maybeCacheCorpus → this decision. `race`,
+ * `race_need`, and `tier` on the body are ignored — the cut is a property
+ * of messages[], not of how many models will read them.
+ *
+ * Oversized: bind the old prefix, forward system + bounded tail, and the
+ * sidecar must set x-hrr-context (setHrrContext). Small: passthrough,
+ * no bind, no header. Does not talk to the network.
+ */
+export function decideChatSpill(body, opts = {}) {
+  const msgs = Array.isArray(body?.messages) ? body.messages : null;
+  if (!msgs?.length) return emptySpillDecision(msgs, 'no-messages');
+  const minChars = opts.minPrefixChars ?? SPILL_MIN_PREFIX_CHARS;
+
+  if (isOneShotCorpusAsk(msgs, minChars)) {
+    const last = msgs[msgs.length - 1];
+    const at = last.content.lastIndexOf('\n\n');
+    const prefix = last.content.slice(0, at);
+    const ask = last.content.slice(at + 2).trim();
+    const forwarded = [...msgs.slice(0, -1), { ...last, content: ask }];
+    return {
+      mode: 'oneshot',
+      reason: 'corpus-question',
+      setHrrContext: true,
+      prefix,
+      ask,
+      forwarded,
+      head: msgs.slice(0, -1),
+      tail: [{ ...last, content: ask }],
+      sentChars: sliceChars(forwarded),
+      unspilledChars: sliceChars(msgs),
+    };
+  }
+
+  const adapted = applySpillCut(msgs, opts);
+  if (adapted.cut <= adapted.firstSpillable) {
+    if (adapted.stubbed?.dropped || adapted.stubbed?.stubbed) {
+      return {
+        mode: 'stub-only',
+        reason: 'no-cut-stubbed',
+        setHrrContext: false,
+        adapted,
+        forwarded: adapted.stubbed.messages,
+        prefix: '',
+        head: [],
+        tail: adapted.stubbed.messages,
+        sentChars: sliceChars(adapted.stubbed.messages),
+        unspilledChars: sliceChars(msgs),
+      };
+    }
+    return { ...emptySpillDecision(msgs, 'no-cut'), adapted };
+  }
+
+  const prefix = msgs.slice(adapted.firstSpillable, adapted.cut)
+    .map(msgText).filter(Boolean).join('\n\n');
+  if (prefix.length <= minChars) {
+    return { ...emptySpillDecision(msgs, 'prefix-under-threshold'), adapted, prefix };
+  }
+
+  const head = msgs.slice(0, adapted.firstSpillable);
+  const tail = adapted.stubbed.messages.slice(adapted.cut);
+  const forwarded = [...head, ...tail];
+  return {
+    mode: 'spill',
+    reason: 'oversized-prefix',
+    setHrrContext: true,
+    adapted,
+    prefix,
+    head,
+    tail,
+    forwarded,
+    cut: adapted.cut,
+    firstSpillable: adapted.firstSpillable,
+    sentChars: sliceChars(forwarded),
+    unspilledChars: sliceChars(msgs),
+  };
+}
+
 /** Session counters the HUD reads off /v1/info. */
 export function createSpillStats() {
   return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openzoo",
-  "version": "0.49.6",
+  "version": "0.49.7",
   "description": "Local x402-paying proxy + MCP server for openzoo.fun — 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",