openzoo 0.48.75 → 0.48.77

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;
@@ -1182,9 +1194,11 @@ 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 });
@@ -1266,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.

package/lib/spill.js

@@ -495,6 +495,58 @@ export function looksLikeFileView(command) {
 /** Tool result larger than this is "fat" — stub it in the forwarded tail. */
 export const FAT_TOOL_CHARS = 400;
 
+/**
+ * Bound-file matching used to stub any size, including a 461-byte Read the
+ * model had just fetched. Stay under this floor unless we are over budget
+ * *and* the result is not this turn's current tool round.
+ */
+export const KEEP_TOOL_CHARS = 4096;
+
+function toolCallIds(m) {
+  if (!m || typeof m !== 'object') return [];
+  const ids = [];
+  if (Array.isArray(m.tool_calls)) {
+    for (const c of m.tool_calls) {
+      const id = c?.id || c?.tool_call_id;
+      if (id) ids.push(id);
+    }
+  }
+  if (m.function_call) {
+    const id = m.function_call.id || m.function_call.tool_call_id;
+    if (id) ids.push(id);
+  }
+  if (Array.isArray(m.content)) {
+    for (const b of m.content) {
+      if (b?.type === 'tool_use' && b.id) ids.push(b.id);
+    }
+  }
+  return ids;
+}
+
+/**
+ * Last assistant that issued tool_calls / tool_use, plus those ids.
+ *
+ * Claude Code / OpenAI put *this turn's* Read/Bash/WebSearch results in
+ * `role:tool` (or tool_result blocks) AFTER the last user ask. Those are
+ * in-flight — the model's current eyes — and must never be stubbed, even
+ * when large. A completed round (tools, then a follow-up ask) may still
+ * be stubbed; that is the 0.48.76 storm savings. The last round's small
+ * bodies still use KEEP_TOOL_CHARS so a 461-byte Read survives.
+ */
+export function currentToolRound(msgs, { lastUser = -1 } = {}) {
+  let index = -1;
+  const ids = new Set();
+  if (!Array.isArray(msgs)) return { index, ids, inFlight: false };
+  for (let i = 0; i < msgs.length; i++) {
+    const here = toolCallIds(msgs[i]);
+    if (!here.length) continue;
+    index = i;
+    ids.clear();
+    for (const id of here) ids.add(id);
+  }
+  return { index, ids, inFlight: index >= 0 && index > lastUser };
+}
+
 export function fileBoundStub(paths, n) {
   const list = [...new Set((paths || []).filter(Boolean))].join(' ');
   const mark = Number.isFinite(n) && n > 0 ? `[bound, ${n} chars]` : '[bound]';
@@ -508,6 +560,38 @@ export function toolResultStub(n, paths) {
   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));
@@ -545,11 +629,21 @@ function resolveBoundPath(raw, cwd, boundAbs) {
  * 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 instead of deleting the tool_use / tool_result pairing.
+ * 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. The last user ask is
- * never rewritten.
+ * never rewritten. The current tool round — last assistant with tool_calls
+ * / tool_use and every matching role:tool / tool_result — is never rewritten
+ * when that assistant sits after the last user ask (this turn's eyes).
+ * Bodies under KEEP_TOOL_CHARS on that last round also stay, even when the
+ * ask follows the results, so a 461-byte Read is not replaced with
+ * `[bound, 461 chars]`.
  */
 export function stubBoundFileResults(msgs, {
   boundFiles,
@@ -558,16 +652,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).
+  // 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 (oldest first) until it fits. Pairing stays; the ask stays.
+  // 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);
   const wantBudget = budget != null && Number.isFinite(Number(budget));
-  if (!Array.isArray(msgs) || (!absSet.size && !aggressive && !wantBudget)) {
+  const wantKeep = keepTail != null && Number.isFinite(Number(keepTail));
+  if (!Array.isArray(msgs) || (!absSet.size && !aggressive && !wantBudget && !wantKeep)) {
     return { messages: msgs, stubbed: 0, dropped: 0 };
   }
 
@@ -613,24 +713,46 @@ export function stubBoundFileResults(msgs, {
     }
   }
 
-  const lastUser = lastUserAskIndex(msgs, firstSpillableIndex(msgs));
+  const firstSpillable = firstSpillableIndex(msgs);
+  let lastUser = lastUserAskIndex(msgs, firstSpillable);
   const fatLimit = Number.isFinite(Number(fatChars)) ? Number(fatChars) : FAT_TOOL_CHARS;
+  const keepFloor = KEEP_TOOL_CHARS;
+  const slimArgs = aggressive || wantBudget;
+  let round = currentToolRound(msgs, { lastUser });
 
   const stubFor = (id, n) => {
     const paths = idPaths.get(id);
     return paths?.length ? fileBoundStub(paths, n) : toolResultStub(n);
   };
 
-  const shouldStubBody = (id, n) => {
+  const shouldStubBody = (id, n, { overBudget = false } = {}) => {
     if (!n || isStubText(typeof n === 'number' ? '' : n)) return false;
+    if (id && round.inFlight && round.ids.has(id)) return false;
+    if (n < keepFloor && (!overBudget || (id && round.ids.has(id)))) return false;
     if (stubIds.has(id)) return true;
-    if (aggressive && n >= fatLimit) return true;
+    if (slimArgs && n >= fatLimit) return true;
     return false;
   };
 
   let stubbed = 0;
   let dropped = 0;
-  let messages = msgs.map((m, i) => {
+  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));
+    round = currentToolRound(messages, { lastUser });
+  }
+
+  const skipSlimCalls = (i) => round.inFlight && i === round.index;
+
+  messages = messages.map((m, i) => {
     if (i < fromIndex || !m || i === lastUser) return m;
     if (m.role === 'tool') {
       const n = toolContentLength(m.content);
@@ -639,9 +761,32 @@ export function stubBoundFileResults(msgs, {
       stubbed += 1;
       return { ...m, content: stubFor(m.tool_call_id, n) };
     }
-    if (!Array.isArray(m.content)) return m;
+    let next = m;
+    if (Array.isArray(m.tool_calls) && slimArgs && !skipSlimCalls(i)) {
+      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 && !skipSlimCalls(i)) {
+      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(next.content)) return next;
     let changed = false;
-    const blocks = m.content.map((b) => {
+    const blocks = next.content.map((b) => {
       if (b?.type !== 'tool_result') return b;
       const n = toolContentLength(b.content);
       if (!shouldStubBody(b.tool_use_id, n) || isStubText(b.content)) return b;
@@ -650,13 +795,14 @@ export function stubBoundFileResults(msgs, {
       changed = true;
       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
-  // 15-result storm used to ride in full at the 800-byte floor. Stub older
-  // bodies first; never drop the ask or the assistant tool_calls themselves.
+  // 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);
@@ -669,7 +815,7 @@ export function stubBoundFileResults(msgs, {
         if (m.role === 'tool') {
           if (isStubText(m.content)) continue;
           const n = toolContentLength(m.content);
-          if (!n) continue;
+          if (!shouldStubBody(m.tool_call_id, n, { overBudget: true })) continue;
           const stub = stubFor(m.tool_call_id, n);
           if (stub.length >= n) continue;
           used = used - n + stub.length;
@@ -678,12 +824,31 @@ export function stubBoundFileResults(msgs, {
           dropped += n;
           continue;
         }
-        if (!Array.isArray(m.content)) continue;
+        if (Array.isArray(m.tool_calls) && !skipSlimCalls(i)) {
+          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 = m.content.map((b) => {
+        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;
+          if (!shouldStubBody(b.tool_use_id, n, { overBudget: true })) return b;
           const stub = stubFor(b.tool_use_id, n);
           if (stub.length >= n) return b;
           used = used - n + stub.length;
@@ -692,9 +857,18 @@ export function stubBoundFileResults(msgs, {
           changed = true;
           return { ...b, content: stub };
         });
-        if (changed) next[i] = { ...m, content: blocks };
+        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),
+        });
+      }
     }
   }
 
@@ -744,15 +918,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;
 }
 
@@ -998,6 +1176,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.
@@ -1069,9 +1299,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,
   });
 }
 
@@ -1108,9 +1339,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) => {
@@ -1126,7 +1363,9 @@ export function applySpillCut(msgs, {
     };
   };
 
-  let stubbed = stubForCut(msgs, plan.cut, { boundFiles, boundAbs, cwd, aggressive: k.stubMore, budget: k.budget });
+  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';
 
@@ -1142,7 +1381,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, budget: k.budget });
+        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.75",
+  "version": "0.48.77",
   "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",