openzoo 0.48.74 → 0.48.76

package/lib/models.js

@@ -269,16 +269,35 @@ export function rewritablePath(method, url) {
  */
 export const REASONING_MODEL_RE = /(deepseek|grok|o[134](-|$)|reasoner|thinking|-pro\b|sol-pro|qwq)/i;
 
-/** Claude Code auto-mode classify is max_tokens=16; treat anything in (0, 64] as one. */
-export const CLASSIFY_MAX_TOKENS = 64;
+/** Claude Code auto-mode classify is max_tokens=16. 0.48.75 used 64 and
+ *  missed grok nubs at 128 / 2000 on a 1–2 message body (dead-steady ~3¢
+ *  from the reasoning floor). Anything in (0, 256] on a short transcript
+ *  is a nub; a fat grok chat still uses the 4000 floor. */
+export const CLASSIFY_MAX_TOKENS = 256;
+export const CLASSIFY_MAX_MSGS = 3;
+export const CLASSIFY_MAX_BODY = 65_536;
 
 const CLASSIFIER_PREFS = ['google/gemini-3.7-flash', 'anthropic/claude-haiku-4.5'];
 
+function messageHasToolCalls(m) {
+  return Boolean(
+    (Array.isArray(m?.tool_calls) && m.tool_calls.length)
+    || m?.function_call
+    || m?.role === 'tool',
+  );
+}
+
 /**
- * Tiny yes/no classify: small body (same BIND_MIN threshold the spill/brief
- * already use) AND a short max_tokens. Detected from the ORIGINAL body,
- * before rewrite or the reasoning floor — otherwise OPENZOO_DEFAULT_MODEL
- * can land the classify on Grok/DeepSeek and the floor turns 16 into 4000.
+ * Tiny classify / grok nub: pin to flash, never apply the reasoning floor.
+ *
+ * 0.48.75 required max_tokens ≤ 64 AND body < BIND_MIN (16k). Live 3¢
+ * asks missed that (max_tokens 128 or 2000, and/or body ≥ 16k from a
+ * tools schema) and then ate the 4000 grok floor. Widen:
+ *   - max_tokens ≤ 256 on a short transcript (≤ 6 msgs, no tool_calls)
+ *   - OR few messages, no tool_calls, body under a few tens of KB
+ *     (even when the caller asked for 2000 tokens)
+ * A real grok chat (max_tokens 2000+ AND a long / tool-using transcript)
+ * still returns false so the floor can fire.
  *
  * `body` may be the raw Buffer/string or a parsed object. An optional
  * `bodyLen` overrides stringify length when the caller still has the wire
@@ -296,7 +315,11 @@ export function isTinyClassify(body, bodyLen) {
     try { len = Buffer.byteLength(JSON.stringify(body)); } catch { return false; }
   }
   const mt = Number(parsed?.max_tokens);
-  return len < BIND_MIN_CHARS && Number.isFinite(mt) && mt > 0 && mt <= CLASSIFY_MAX_TOKENS;
+  if (!Number.isFinite(mt) || mt <= 0) return false;
+  const messages = Array.isArray(parsed?.messages) ? parsed.messages : [];
+  if (messages.some(messageHasToolCalls)) return false;
+  if (mt <= CLASSIFY_MAX_TOKENS && messages.length <= 6) return true;
+  return messages.length <= CLASSIFY_MAX_MSGS && len < CLASSIFY_MAX_BODY;
 }
 
 /**

package/lib/proxy.js

@@ -16,7 +16,7 @@ import {
   loadBoundChars, noteCorpusLedger, filesForCorpus, readFilesForCorpus, boundAbsFromKeys,
   createSpillStats, corpusCharsForSend, applySpillCut, msgText,
 } from './spill.js';
-import { rewritablePath, augmentModelList, ALIAS_IDS, rewriteChatModel, zooModelIds } from './models.js';
+import { rewritablePath, augmentModelList, ALIAS_IDS, rewriteChatModel, zooModelIds, CLASSIFY_MAX_TOKENS } from './models.js';
 import { forgetContext } from './contexts.js';
 import { injectBrief } from './brief.js';
 import { withNamespace } from './namespace.js';
@@ -440,6 +440,18 @@ async function spillTranscript(body, log, req, stats) {
   });
   if (adapted.cut <= adapted.firstSpillable) {
     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;
   }
   const { cut, firstSpillable } = adapted;
@@ -749,6 +761,9 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       mkdirSync(path.dirname(sayFile), { recursive: true });
     } catch { sayFile = null; }
   }
+  // Spill/adapt/classifier lines must use this channel: `log` is a no-op when
+  // `openzoo claude` starts us with silent:true, and printing them on stdout
+  // corrupts the Claude Code TTY. say() writes ~/.openzoo/proxy.log then.
   const say = (...a) => {
     const line = a.join(' ');
     if (sayFile) { try { appendFileSync(sayFile, line + '\n'); return; } catch { /* fall through */ } }
@@ -1179,15 +1194,19 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         // temporarily unavailable (timed out), so auto mode cannot determine
         // the safety of WebSearch". Even staying on sonnet-5 is too slow
         // (402 handshake behind a long Grok stream). Pin to a fast
-        // non-reasoning catalog id and leave max_tokens at 16. Real
-        // Grok/DeepSeek chats (max_tokens > 64 or a body over BIND_MIN)
+        // non-reasoning catalog id and leave max_tokens alone. Real
+        // Grok/DeepSeek chats (max_tokens 2000+ AND a long transcript)
         // still get the 4000 floor � those still go blank without it.
+        // 0.48.75 missed grok nubs at max_tokens 128/2000 on a 1�2
+        // message body (~3� from the floor, no classifier log).
         let ids = [];
         try { ids = await zooModelIds(); } catch { /* catalog miss: still skip the floor on a tiny classify */ }
         const policy = rewriteChatModel(parsed, ids, { bodyLen: bodyBuf.length });
         parsed = policy.parsed;
         if (policy.tiny) {
-          log(`classifier tiny max_tokens=${Number(parsed?.max_tokens)} "${policy.from}" -> ${policy.to} (no reasoning floor)`);
+          // `openzoo claude` starts us silent � `log` is a no-op then. say()
+          // is the proxy.log channel and never the Claude Code TTY.
+          say(`classifier tiny max_tokens=${Number(parsed?.max_tokens)} "${policy.from}" -> ${policy.to} (no reasoning floor)`);
         } else {
           // SAY WHETHER THE OVERRIDE IS ACTUALLY SET, and name it.
           //
@@ -1261,7 +1280,7 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
           const tiny = policy.tiny
             || (bodyBuf.length < BIND_MIN_CHARS
               && Number(parsed?.max_tokens ?? 0) > 0
-              && Number(parsed?.max_tokens) <= 64);
+              && Number(parsed?.max_tokens) <= CLASSIFY_MAX_TOKENS);
           const briefed = tiny ? null : injectBrief(parsed, selfUrl);
           if (briefed) parsed = briefed;
           // SYSTEM MESSAGES BELONG AT THE FRONT, OR GOOGLE 400s.
@@ -1372,7 +1391,9 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
     try {
       let cached = null;
       try {
-        cached = await maybeCacheCorpus(req, bodyBuf, log, spill);
+        // Spill/adapt diagnostics (adapt, file-stub, sending N/M) must hit
+        // ~/.openzoo/proxy.log when we are silent. `log` is a no-op then.
+        cached = await maybeCacheCorpus(req, bodyBuf, say, spill);
       } catch (err) {
         log(`context cache skipped for this call: ${err.message}`);
       }

package/lib/spill.js

@@ -492,9 +492,58 @@ export function looksLikeFileView(command) {
   return sawView;
 }
 
-export function fileBoundStub(paths) {
+/** Tool result larger than this is "fat" — stub it in the forwarded tail. */
+export const FAT_TOOL_CHARS = 400;
+
+export function fileBoundStub(paths, n) {
+  const list = [...new Set((paths || []).filter(Boolean))].join(' ');
+  const mark = Number.isFinite(n) && n > 0 ? `[bound, ${n} chars]` : '[bound]';
+  return list ? `FILE ${list} ${mark}` : `FILE ${mark}`;
+}
+
+/** Generic stub for WebSearch / Fetch / Bash / any fat tool_result. */
+export function toolResultStub(n, paths) {
   const list = [...new Set((paths || []).filter(Boolean))].join(' ');
-  return list ? `FILE ${list} [bound]` : 'FILE [bound]';
+  const mark = `[bound, ${Number(n) || 0} chars]`;
+  return list ? `FILE ${list} ${mark}` : mark;
+}
+
+function toolCallArgLength(tc) {
+  const a = tc?.function?.arguments ?? tc?.arguments;
+  if (typeof a === 'string') return a.length;
+  if (a && typeof a === 'object') return JSON.stringify(a).length;
+  return 0;
+}
+
+/**
+ * Keep path/query/url/command so pairing still names the call; drop the
+ * fat payload (Write contents, Edit hunks, pasted Bash, tool JSON).
+ */
+export function slimToolCallArgs(tc, n) {
+  const args = parseArgs(tc?.function?.arguments ?? tc?.arguments);
+  const slim = {};
+  for (const k of PATH_KEYS) {
+    if (typeof args[k] === 'string' && args[k]) slim[k] = args[k];
+  }
+  if (typeof args.query === 'string') {
+    slim.query = args.query.length > 240 ? `${args.query.slice(0, 240)}…` : args.query;
+  }
+  if (typeof args.url === 'string') {
+    slim.url = args.url.length > 300 ? `${args.url.slice(0, 300)}…` : args.url;
+  }
+  if (typeof args.command === 'string') {
+    slim.command = args.command.length > 240 ? `${args.command.slice(0, 240)}…` : args.command;
+  }
+  slim._stub = `[bound, ${Number(n) || 0} chars]`;
+  const encoded = JSON.stringify(slim);
+  if (tc?.function) return { ...tc, function: { ...tc.function, arguments: encoded } };
+  return { ...tc, arguments: encoded };
+}
+
+function isStubText(content) {
+  if (typeof content === 'string') return /\[bound(?:, \d+ chars)?\]/.test(content);
+  if (Array.isArray(content)) return content.some((b) => isStubText(typeof b === 'string' ? b : b?.text ?? b?.content));
+  return false;
 }
 
 function toolContentLength(content) {
@@ -524,10 +573,20 @@ function resolveBoundPath(raw, cwd, boundAbs) {
  * (live: 5MB filebind, lastSend 13/107, savingX 1.22 instead of ~7x).
  *
  * Cheap rewrite — no disk I/O. First-read results (not yet in boundAbs) and
- * non-file tool output (npm test, grep, …) stay verbatim. The ask stays.
+ * non-file tool output stay verbatim UNLESS `aggressive` / `stubMore` or a
+ * tail `budget` is set. Those two are what beat a WebSearch/Fetch/Bash
+ * storm: the 800-byte floor cannot move `cut` inside a tool chain
+ * (`isSeverable` is false), so the byte budget has to win by stubbing
+ * bodies (and fat tool_call JSON) instead of orphaning a pairing.
+ *
+ * `keepTail` is the vote cutTranscript cannot cast on an un-severable
+ * chain: drop older complete tool_call + tool_result pairs (rewrite the
+ * assistant's tool_calls, do not leave orphans). Live 0.48.75: keep 16/8/6/2
+ * all cut at the same index and left ~728k after file-only stubs.
  *
  * `fromIndex` limits the rewrite to the forwarded tail so the spilled prefix
- * that becomes the conversation corpus is unchanged.
+ * that becomes the conversation corpus is unchanged. The last user ask is
+ * never rewritten.
  */
 export function stubBoundFileResults(msgs, {
   boundFiles,
@@ -536,10 +595,22 @@ export function stubBoundFileResults(msgs, {
   fromIndex = 0,
   // When the live tuner is below target, stub file-view results even if
   // this turn has not yet recorded them in boundAbs (first-read bodies).
+  // Also stubs fat non-file tools (WebSearch / Fetch / Bash) and fat
+  // tool_call argument JSON.
   aggressive = false,
+  // When the forwarded tail is over this many chars, stub older tool_result
+  // bodies and fat tool_call JSON (oldest first) until it fits. Pairing
+  // stays; the ask stays. If still over, drop older complete pairs.
+  budget = null,
+  // How many complete tool pairs to keep at the end of an un-severable
+  // assistant(tool_calls)+results chain. Ignored when the tail is severable.
+  keepTail = null,
+  fatChars = FAT_TOOL_CHARS,
 } = {}) {
   const absSet = boundAbs || boundAbsFromKeys(boundFiles);
-  if (!Array.isArray(msgs) || (!absSet.size && !aggressive)) {
+  const wantBudget = budget != null && Number.isFinite(Number(budget));
+  const wantKeep = keepTail != null && Number.isFinite(Number(keepTail));
+  if (!Array.isArray(msgs) || (!absSet.size && !aggressive && !wantBudget && !wantKeep)) {
     return { messages: msgs, stubbed: 0, dropped: 0 };
   }
 
@@ -585,32 +656,158 @@ export function stubBoundFileResults(msgs, {
     }
   }
 
-  if (!stubIds.size) return { messages: msgs, stubbed: 0, dropped: 0 };
+  const firstSpillable = firstSpillableIndex(msgs);
+  let lastUser = lastUserAskIndex(msgs, firstSpillable);
+  const fatLimit = Number.isFinite(Number(fatChars)) ? Number(fatChars) : FAT_TOOL_CHARS;
+  const slimArgs = aggressive || wantBudget;
+
+  const stubFor = (id, n) => {
+    const paths = idPaths.get(id);
+    return paths?.length ? fileBoundStub(paths, n) : toolResultStub(n);
+  };
+
+  const shouldStubBody = (id, n) => {
+    if (!n || isStubText(typeof n === 'number' ? '' : n)) return false;
+    if (stubIds.has(id)) return true;
+    if (slimArgs && n >= fatLimit) return true;
+    return false;
+  };
 
   let stubbed = 0;
   let dropped = 0;
-  const messages = msgs.map((m, i) => {
-    if (i < fromIndex || !m) return m;
-    if (m.role === 'tool' && stubIds.has(m.tool_call_id)) {
+  let messages = msgs;
+
+  // keepTail votes here because cutTranscript cannot move inside the chain.
+  if (wantKeep) {
+    messages = trimUnseverablePairs(messages, {
+      fromIndex,
+      keepTail: Number(keepTail),
+      lastUser,
+      firstSpillable,
+    });
+    lastUser = lastUserAskIndex(messages, firstSpillableIndex(messages));
+  }
+
+  messages = messages.map((m, i) => {
+    if (i < fromIndex || !m || i === lastUser) return m;
+    if (m.role === 'tool') {
       const n = toolContentLength(m.content);
-      if (!n) return m;
+      if (!shouldStubBody(m.tool_call_id, n) || isStubText(m.content)) return m;
       dropped += n;
       stubbed += 1;
-      return { ...m, content: fileBoundStub(idPaths.get(m.tool_call_id)) };
+      return { ...m, content: stubFor(m.tool_call_id, n) };
+    }
+    let next = m;
+    if (Array.isArray(m.tool_calls) && slimArgs) {
+      let changed = false;
+      const calls = m.tool_calls.map((tc) => {
+        const n = toolCallArgLength(tc);
+        const raw = tc?.function?.arguments ?? tc?.arguments;
+        if (n < fatLimit || isStubText(typeof raw === 'string' ? raw : '')) return tc;
+        dropped += n;
+        stubbed += 1;
+        changed = true;
+        return slimToolCallArgs(tc, n);
+      });
+      if (changed) next = { ...next, tool_calls: calls };
+    }
+    if (next.function_call && slimArgs) {
+      const n = toolCallArgLength(next.function_call);
+      const raw = next.function_call.arguments;
+      if (n >= fatLimit && !isStubText(typeof raw === 'string' ? raw : '')) {
+        dropped += n;
+        stubbed += 1;
+        next = { ...next, function_call: slimToolCallArgs(next.function_call, n) };
+      }
     }
-    if (!Array.isArray(m.content)) return m;
+    if (!Array.isArray(next.content)) return next;
     let changed = false;
-    const blocks = m.content.map((b) => {
-      if (b?.type !== 'tool_result' || !stubIds.has(b.tool_use_id)) return b;
+    const blocks = next.content.map((b) => {
+      if (b?.type !== 'tool_result') return b;
       const n = toolContentLength(b.content);
-      if (!n) return b;
+      if (!shouldStubBody(b.tool_use_id, n) || isStubText(b.content)) return b;
       dropped += n;
       stubbed += 1;
       changed = true;
-      return { ...b, content: fileBoundStub(idPaths.get(b.tool_use_id)) };
+      return { ...b, content: stubFor(b.tool_use_id, n) };
     });
-    return changed ? { ...m, content: blocks } : m;
+    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.
+  if (wantBudget) {
+    const cap = Number(budget);
+    let used = sliceChars(messages, fromIndex);
+    if (used > cap) {
+      const next = messages.slice();
+      for (let i = fromIndex; i < next.length && used > cap; i++) {
+        if (i === lastUser) continue;
+        const m = next[i];
+        if (!m) continue;
+        if (m.role === 'tool') {
+          if (isStubText(m.content)) continue;
+          const n = toolContentLength(m.content);
+          if (!n) continue;
+          const stub = stubFor(m.tool_call_id, n);
+          if (stub.length >= n) continue;
+          used = used - n + stub.length;
+          next[i] = { ...m, content: stub };
+          stubbed += 1;
+          dropped += n;
+          continue;
+        }
+        if (Array.isArray(m.tool_calls)) {
+          let changed = false;
+          const calls = m.tool_calls.map((tc) => {
+            if (used <= cap) return tc;
+            const n = toolCallArgLength(tc);
+            const raw = tc?.function?.arguments ?? tc?.arguments;
+            if (n < fatLimit || isStubText(typeof raw === 'string' ? raw : '')) return tc;
+            const slim = slimToolCallArgs(tc, n);
+            const after = toolCallArgLength(slim);
+            if (after >= n) return tc;
+            used = used - n + after;
+            stubbed += 1;
+            dropped += n;
+            changed = true;
+            return slim;
+          });
+          if (changed) next[i] = { ...m, tool_calls: calls };
+        }
+        if (!Array.isArray((next[i] || m).content)) continue;
+        const cur = next[i];
+        let changed = false;
+        const blocks = cur.content.map((b) => {
+          if (b?.type !== 'tool_result' || used <= cap || isStubText(b.content)) return b;
+          const n = toolContentLength(b.content);
+          if (!n) return b;
+          const stub = stubFor(b.tool_use_id, n);
+          if (stub.length >= n) return b;
+          used = used - n + stub.length;
+          stubbed += 1;
+          dropped += n;
+          changed = true;
+          return { ...b, content: stub };
+        });
+        if (changed) next[i] = { ...cur, content: blocks };
+      }
+      messages = next;
+      used = sliceChars(messages, fromIndex);
+      if (used > cap) {
+        messages = trimUnseverablePairs(messages, {
+          fromIndex,
+          keepTail: 1,
+          lastUser,
+          firstSpillable: firstSpillableIndex(messages),
+        });
+      }
+    }
+  }
+
   return { messages, stubbed, dropped };
 }
 
@@ -657,15 +854,19 @@ export function messageChars(m) {
   else if (Array.isArray(c)) {
     for (const b of c) {
       if (typeof b === 'string') n += b.length;
-      else n += String(b?.text ?? (typeof b?.content === 'string' ? b.content : '')).length;
+      else if (b && typeof b === 'object') {
+        if (typeof b.text === 'string') n += b.text.length;
+        else if (typeof b.content === 'string') n += b.content.length;
+        else if (b.content != null) n += toolContentLength(b.content);
+        else n += JSON.stringify(b).length;
+      }
     }
   } else if (c && typeof c === 'object') n += JSON.stringify(c).length;
   if (Array.isArray(m.tool_calls)) {
-    for (const tc of m.tool_calls) {
-      const a = tc?.function?.arguments ?? tc?.arguments;
-      n += typeof a === 'string' ? a.length : (a ? JSON.stringify(a).length : 0);
-    }
+    for (const tc of m.tool_calls) n += toolCallArgLength(tc);
   }
+  const legacy = m.function_call;
+  if (legacy) n += toolCallArgLength(legacy);
   return n;
 }
 
@@ -911,6 +1112,58 @@ function isSeverable(msgs, i, firstSpillable) {
   return msgs[i].role !== 'tool';
 }
 
+/**
+ * On an un-severable assistant(tool_calls)+results chain, keepTail cannot
+ * move `cut`. Drop older complete pairs (rewrite tool_calls, drop their
+ * results) so keep 16 vs 2 actually differ and the byte budget can land.
+ */
+export function trimUnseverablePairs(msgs, {
+  fromIndex = 0,
+  keepTail = 2,
+  lastUser = -1,
+  firstSpillable = 0,
+} = {}) {
+  if (!Array.isArray(msgs) || !msgs.length) return msgs;
+  const keep = Math.max(1, Math.round(Number(keepTail) || 2));
+  const end = lastUser > fromIndex ? lastUser : msgs.length;
+  let asstIdx = -1;
+  for (let i = fromIndex; i < end; i++) {
+    if (Array.isArray(msgs[i]?.tool_calls) && msgs[i].tool_calls.length) {
+      asstIdx = i;
+      break;
+    }
+  }
+  if (asstIdx < 0) return msgs;
+  for (let i = asstIdx + 1; i < end; i++) {
+    if (isSeverable(msgs, i, firstSpillable)) return msgs;
+  }
+  const calls = msgs[asstIdx].tool_calls;
+  if (calls.length <= keep) return msgs;
+  const keptCalls = calls.slice(-keep);
+  const keptIds = new Set(keptCalls.map((c) => c.id).filter(Boolean));
+  const out = [];
+  for (let i = 0; i < msgs.length; i++) {
+    const m = msgs[i];
+    if (i === asstIdx) {
+      out.push({ ...m, tool_calls: keptCalls });
+      continue;
+    }
+    if (i > asstIdx && i !== lastUser && m?.role === 'tool' && m.tool_call_id && !keptIds.has(m.tool_call_id)) {
+      continue;
+    }
+    if (i > asstIdx && i !== lastUser && Array.isArray(m?.content)) {
+      const blocks = m.content.filter((b) => b?.type !== 'tool_result' || keptIds.has(b.tool_use_id));
+      if (blocks.length !== m.content.length) {
+        if (!blocks.length && m.role !== 'assistant') continue;
+        out.push({ ...m, content: blocks });
+        continue;
+      }
+    }
+    out.push(m);
+  }
+  return out;
+}
+
 /**
  * Pick a severable cut: keep a recent tail, honour the byte budget, floor
  * at minTurns of user/assistant, and never drop the last user ask.
@@ -940,6 +1193,11 @@ export function cutTranscript(msgs, knobs = {}) {
     return { cut: -1, firstSpillable, lastUser: lastUserAskIndex(msgs, firstSpillable), knobs: k };
   }
 
+  // Only moves the cut at a severable index. A current-turn tool storm
+  // (assistant(tool_calls) + N tool results + user ask) has no severable
+  // 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.
   let tailStart = cut;
   {
     let used = 0;
@@ -977,8 +1235,10 @@ function stubForCut(msgs, cut, opts) {
     boundFiles: opts.boundFiles,
     boundAbs: opts.boundAbs,
     cwd: opts.cwd,
-    fromIndex: cut,
+    fromIndex: Math.max(0, cut),
     aggressive: Boolean(opts.aggressive),
+    budget: opts.budget,
+    keepTail: opts.keepTail,
   });
 }
 
@@ -1015,9 +1275,15 @@ export function applySpillCut(msgs, {
     action: 'hold',
   };
   if (plan.cut <= plan.firstSpillable) {
-    const sentChars = sliceChars(msgs, 0);
+    // No severable index — still stub/trim the un-severable tail so a
+    // 300-result storm is not forwarded at full size.
+    const stubFrom = plan.firstSpillable >= 0 ? plan.firstSpillable : 0;
+    const stubbed = stubForCut(msgs, stubFrom, {
+      boundFiles, boundAbs, cwd, aggressive: k.stubMore, budget: k.budget, keepTail: k.keepTail,
+    });
+    const sentChars = sliceChars(stubbed.messages, stubFrom);
     const corpus = Math.max(Number(corpusChars) || 0, sentChars);
-    return { ...empty, sentChars, ratio: spillRatio(corpus, sentChars) };
+    return { ...empty, stubbed, sentChars, ratio: spillRatio(corpus, sentChars) };
   }
 
   const measure = (cut, stubbed, knobsNow) => {
@@ -1033,7 +1299,9 @@ export function applySpillCut(msgs, {
     };
   };
 
-  let stubbed = stubForCut(msgs, plan.cut, { boundFiles, boundAbs, cwd, aggressive: k.stubMore });
+  let stubbed = stubForCut(msgs, plan.cut, {
+    boundFiles, boundAbs, cwd, aggressive: k.stubMore, budget: k.budget, keepTail: k.keepTail,
+  });
   let stats = measure(plan.cut, stubbed, k);
   let action = 'hold';
 
@@ -1049,7 +1317,9 @@ export function applySpillCut(msgs, {
     if (decision.recut) {
       plan = cutTranscript(msgs, k);
       if (plan.cut > plan.firstSpillable) {
-        stubbed = stubForCut(msgs, plan.cut, { boundFiles, boundAbs, cwd, aggressive: k.stubMore });
+        stubbed = stubForCut(msgs, plan.cut, {
+          boundFiles, boundAbs, cwd, aggressive: k.stubMore, budget: k.budget, keepTail: k.keepTail,
+        });
         stats = measure(plan.cut, stubbed, k);
       }
     }

package/package.json

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