openzoo 0.48.72 → 0.48.75

package/lib/models.js

@@ -1,5 +1,9 @@
 import { config } from './config.js';
 
+/** Same threshold as BIND_MIN_CHARS in hrr.js — kept local so this
+ *  module stays importable without the wallet/rpc stack. */
+const BIND_MIN_CHARS = Number(process.env.OPENZOO_CONTEXT_MIN_CHARS || 16384);
+
 /**
  * Model-id rewriting — "any harness, zero model setup".
  *
@@ -257,11 +261,124 @@ export function rewritablePath(method, url) {
   return !/embed|audio|image|moderation/.test(p);
 }
 
+/**
+ * Families that spend max_tokens on hidden thinking first. A 16/40/160
+ * budget on these returns an empty visible completion — measured on Grok
+ * and DeepSeek. The raise in raiseReasoningMaxTokens exists for that.
+ * It must NEVER fire on Claude Code's 16-token auto-mode classifier.
+ */
+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;
+
+const CLASSIFIER_PREFS = ['google/gemini-3.7-flash', 'anthropic/claude-haiku-4.5'];
+
+/**
+ * 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.
+ *
+ * `body` may be the raw Buffer/string or a parsed object. An optional
+ * `bodyLen` overrides stringify length when the caller still has the wire
+ * bytes (the proxy does).
+ */
+export function isTinyClassify(body, bodyLen) {
+  let parsed = body;
+  let len = bodyLen;
+  if (body == null) return false;
+  if (typeof body === 'string' || Buffer.isBuffer(body)) {
+    const buf = Buffer.isBuffer(body) ? body : Buffer.from(body);
+    len = buf.length;
+    try { parsed = JSON.parse(buf.toString('utf8')); } catch { return false; }
+  } else if (len == null) {
+    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;
+}
+
+/**
+ * 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.
+ */
+export function pickClassifierModel(ids, preferred = process.env.OPENZOO_CLASSIFIER_MODEL) {
+  if (!Array.isArray(ids) || !ids.length) return null;
+  if (preferred && ids.includes(preferred)) return preferred;
+  for (const id of CLASSIFIER_PREFS) {
+    if (ids.includes(id)) return id;
+  }
+  return ids.find((id) => !REASONING_MODEL_RE.test(id)) || null;
+}
+
+/**
+ * Raise max_tokens for a reasoning model. Returns { parsed, raised, from, to }.
+ * Does not itself decide whether a request is a classify — callers skip this
+ * when isTinyClassify is true. Real Grok/DeepSeek chats still need the floor:
+ * 4× a caller's 40 is 160, and those still come back blank.
+ */
+export function raiseReasoningMaxTokens(parsed, env = process.env) {
+  const mult = Number(env.OPENZOO_REASONING_MAX_TOKENS_X || 4);
+  const cap = Number(env.OPENZOO_REASONING_MAX_TOKENS_CAP || 32000);
+  const floor = Number(env.OPENZOO_REASONING_MIN_TOKENS || 4000);
+  const mdl = String(parsed?.model || '');
+  const mt = Number(parsed?.max_tokens);
+  if (mult > 1 && REASONING_MODEL_RE.test(mdl) && Number.isFinite(mt) && mt > 0 && mt < cap) {
+    const raised = Math.min(cap, Math.max(floor, Math.round(mt * mult)));
+    if (raised > mt) {
+      return { parsed: { ...parsed, max_tokens: raised }, raised: true, from: mt, to: raised };
+    }
+  }
+  return { parsed, raised: false, from: mt, to: mt };
+}
+
+/**
+ * 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.
+ */
+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;
+    return {
+      parsed: (to && to !== from) ? { ...parsed, model: to } : parsed,
+      tiny: true,
+      from,
+      to,
+      raised: false,
+    };
+  }
+  if (typeof from !== 'string') {
+    return { parsed, tiny: false, from, to: from, raised: false };
+  }
+  const resolved = resolveModel(from, ids);
+  const next = resolved ? { ...parsed, model: resolved } : parsed;
+  const bump = raiseReasoningMaxTokens(next);
+  return {
+    parsed: bump.parsed,
+    tiny: false,
+    from,
+    to: next.model,
+    raised: bump.raised,
+    raisedFrom: bump.from,
+    raisedTo: bump.to,
+  };
+}
+
 /**
  * Rewrite the model field of any request body that has one.
- * Returns null (send as-is) or { body, from, to }. Any failure — bad JSON,
- * unreachable catalog — returns null: this layer must never break a call
- * that would have worked without it.
+ * Returns null (send as-is) or { body, from, to, tiny?, raised? }. Any
+ * failure — bad JSON, unreachable catalog — returns null: this layer must
+ * never break a call that would have worked without it.
+ *
+ * Tiny classify is pinned here too, so OPENZOO_DEFAULT_MODEL cannot capture
+ * a 16-token yes/no even if a caller only goes through this helper.
  */
 export async function maybeRewriteModel(bodyBuf) {
   let body;
@@ -269,7 +386,15 @@ export async function maybeRewriteModel(bodyBuf) {
   if (typeof body?.model !== 'string') return null;
   let ids;
   try { ids = await zooModelIds(); } catch { return null; }
-  const to = resolveModel(body.model, ids);
-  if (!to) return null;
-  return { body: Buffer.from(JSON.stringify({ ...body, model: to })), from: body.model, to };
+  const policy = rewriteChatModel(body, ids, { bodyLen: bodyBuf.length });
+  if (!policy.tiny && !policy.raised && policy.to === body.model) return null;
+  return {
+    body: Buffer.from(JSON.stringify(policy.parsed)),
+    from: body.model,
+    to: policy.parsed.model,
+    tiny: policy.tiny,
+    raised: policy.raised,
+    raisedFrom: policy.raisedFrom,
+    raisedTo: policy.raisedTo,
+  };
 }

package/lib/proxy.js

@@ -14,9 +14,9 @@ import { evmTokenBalance } from './evm.js';
 import { bindCorpus, contextCacheDisabled, BIND_MIN_CHARS } from './hrr.js';
 import {
   loadBoundChars, noteCorpusLedger, filesForCorpus, readFilesForCorpus, boundAbsFromKeys,
-  stubBoundFileResults, createSpillStats, corpusCharsForSend,
+  createSpillStats, corpusCharsForSend, applySpillCut, msgText,
 } from './spill.js';
-import { maybeRewriteModel, rewritablePath, augmentModelList, ALIAS_IDS } from './models.js';
+import { rewritablePath, augmentModelList, ALIAS_IDS, rewriteChatModel, zooModelIds } from './models.js';
 import { forgetContext } from './contexts.js';
 import { injectBrief } from './brief.js';
 import { withNamespace } from './namespace.js';
@@ -331,26 +331,6 @@ function replayPut(key, data, settle) {
  * to sending the original body untouched — caching must never break a call.
  * Returns null (send as-is) or { body, contextId, hash, corpus, reused, savedBytes }.
  */
-/** Flatten one Anthropic content block to text leCore can index. */
-function blockText(b) {
-  if (typeof b === 'string') return b;
-  if (!b || typeof b !== 'object') return '';
-  if (b.type === 'text') return b.text || '';
-  if (b.type === 'tool_use') return `[tool_use ${b.name}] ${JSON.stringify(b.input ?? {})}`;
-  if (b.type === 'tool_result') {
-    const c = b.content;
-    return `[tool_result] ${typeof c === 'string' ? c : (Array.isArray(c) ? c.map(blockText).join('\n') : JSON.stringify(c ?? ''))}`;
-  }
-  if (b.type === 'thinking') return '';        // never bind reasoning traces
-  return '';
-}
-
-function msgText(m) {
-  const c = m?.content;
-  const body = typeof c === 'string' ? c : (Array.isArray(c) ? c.map(blockText).filter(Boolean).join('\n') : '');
-  return body ? `${(m.role || '?').toUpperCase()}: ${body}` : '';
-}
-
 /**
  * Spill the OLD prefix of a long TRANSCRIPT into leCore.
  *
@@ -441,155 +421,29 @@ async function spillTranscript(body, log, req, stats) {
     return null;
   }
 
-  // Keep the recent tail, but never more than half the transcript: a fixed 8 on
-  // a 10-message body left only index 2 to search, which is rarely a user turn,
-  // so a SHORT-but-huge transcript (one giant tool_result) silently never
-  // spilled — the exact case an agent hits first.
-  const keepTail = Math.min(
-    Number(process.env.OPENZOO_KEEP_TAIL_MSGS || 8),
-    Math.max(2, Math.floor(msgs.length / 2)),
-  );
-  const firstSpillable = msgs.findIndex((m) => m?.role !== 'system');
-  if (firstSpillable < 0) return null;
-
-  // A SEVERABLE BOUNDARY IS NOT ONLY A `user` TURN.
-  //
-  // That was the whole bug: in a Claude Code agent loop the human speaks ONCE
-  // and everything after is assistant->tool pairs, so a rule that only cuts at
-  // role:"user" finds nothing and the spill returns null on EVERY turn.
-  // MEASURED against the live proxy log: 104 real claude-cli requests, zero
-  // spills, while every synthetic transcript I tested spilled fine because I
-  // had written user turns into it.
-  //
-  // What actually matters is that no assistant `tool_calls` is left unanswered
-  // across the cut. So any message is a legal boundary when the one BEFORE it
-  // is not an unanswered tool call — i.e. the previous message is a plain
-  // assistant/user/tool with every call already resolved.
-  const severable = (i) => {
-    if (i <= firstSpillable || i >= msgs.length) return false;
-    const prev = msgs[i - 1];
-    if (!prev) return false;
-    // an assistant that issued tool_calls must be followed by its tool results
-    if (prev.role === 'assistant' && Array.isArray(prev.tool_calls) && prev.tool_calls.length) return false;
-    // never split a tool_call/tool_result run in the middle
-    return msgs[i].role !== 'tool';
-  };
-  let cut = -1;
-  for (let i = msgs.length - keepTail; i > firstSpillable; i--) {
-    if (severable(i)) { cut = i; break; }
-  }
-  // FALL BACK TO THE LAST SEVERABLE TURN. The keepTail window is a preference,
-  // not a requirement: a transcript can be enormous and still have very few
-  // user turns (one huge document, then tool traffic), and on those the window
-  // contained no `user` message at all — so nothing spilled and the whole body
-  // went upstream while the counter honestly reported 0. Keep at least the
-  // final turn; anything earlier that is severable is better than not spilling.
-  if (cut <= firstSpillable) {
-    for (let i = msgs.length - 2; i > firstSpillable; i--) {
-      if (severable(i)) { cut = i; break; }
-    }
-  }
-  if (cut <= firstSpillable) {
+  // LIVE SELF-TUNER. Env knobs seed the first cut; after cut+stub the proxy
+  // measures corpus/sent and retunes keep/min-turns/budget (and stubs more)
+  // in process memory so the next request starts from the last good setting.
+  // 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.
+  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, {
+    corpusChars: knownChars,
+    boundAbs: previouslyBoundAbs,
+    log,
+    persist: true,
+  });
+  if (adapted.cut <= adapted.firstSpillable) {
     bindFilesInBackground('no severable cut, files only');
-    return null;                                  // nothing safely severable
-  }
-
-  // TRIM THE TAIL BY BYTES, NOT MESSAGE COUNT.
-  //
-  // MEASURED on the live session: 9 kept turns of Claude Code tool output made
-  // promptTokens swamp the counterfactual and the call scored 1.00x, while the
-  // SAME bound context with a one-line ask scored 8.53x. Nine messages is a
-  // trivial number and an enormous payload — a single Read or grep result is
-  // tens of KB — so counting messages measures the wrong thing entirely.
-  //
-  // Walk backwards from the newest and stop at a byte budget. The newest turns
-  // are the ones the model actually needs verbatim; everything older is already
-  // in the bound corpus and comes back through recall.
-  let tailStart = cut;
-  {
-    // 24000 was still too fat: MEASURED on 9 live spilled calls, direct came
-    // back identical to billed to the cent, i.e. the gateway never computed a
-    // counterfactual because promptTokens >= corpusTokens. The tail has to be
-    // small enough that the BOUND corpus is the bigger number.
-    const budget = Number(process.env.OPENZOO_TAIL_MAX_CHARS || 6000);
-    let used = 0;
-    for (let i = msgs.length - 1; i >= cut; i--) {
-      used += msgText(msgs[i]).length;
-      if (used > budget && severable(i)) { tailStart = i; break; }
-    }
-  }
-  if (tailStart > cut) cut = tailStart;
-
-  // COHERENCE IS COUNTED IN TURNS, NOT BYTES.
-  //
-  // The byte budget alone produced windows of 2, 5 and 34 turns out of ~600 —
-  // and one fat tool result is enough to spend the whole 6,000 chars, so a busy
-  // agent turn collapses the window to almost nothing. OBSERVED live: an agent
-  // that had just run a command reported "I don't have the preceding turns of
-  // this conversation in view" and re-derived its own state from files, every
-  // turn. Retrieval brings back what is RELEVANT to the ask; it does not
-  // reliably bring back "what I just did", because the model does not know to
-  // query for it.
-  //
-  // So floor the window at a number of turns regardless of size. This costs
-  // saving — a bigger tail is a bigger `sent` — and that is the correct trade:
-  // measured 8.13x on the fleet leaves room to spend some of it on an agent
-  // that remembers its own last few moves.
-  // 12 was set while the model was ALSO missing its own last turn to a brief
-  // spliced in behind it (fixed in 0.48.56), so part of that floor was paying
-  // for a bug rather than for coherence. 6 turns still covers "what did I just
-  // do" — the case retrieval cannot answer, because the model does not know to
-  // query for it — and hands the rest back as saving.
-  // COUNT CONVERSATION TURNS, NOT MESSAGES.
-  //
-  // A tool round trip is TWO messages (assistant tool_call + tool result), so a
-  // floor of 6 messages is three tool calls and nothing else — the agent loses
-  // the human turn that started the run and every decision it made along the
-  // way. OBSERVED: "it's when he calls a bunch of tools, he gets lost."
-  //
-  // So the floor is measured in user/assistant turns and tool traffic rides
-  // along for free. A tool-heavy stretch therefore widens the window instead of
-  // consuming it, which is the opposite of the old behaviour and the whole
-  // point: what the agent needs verbatim is what it DID, and doing things is
-  // exactly what fills the window with tool messages.
-  const minTurns = Number(process.env.OPENZOO_TAIL_MIN_TURNS || 6);
-  const realTurns = (from) => {
-    let n = 0;
-    for (let i = from; i < msgs.length; i++) {
-      const r = msgs[i]?.role;
-      if (r === 'user' || r === 'assistant') n += 1;
-    }
-    return n;
-  };
-  if (realTurns(cut) < minTurns) {
-    for (let i = cut - 1; i > firstSpillable; i--) {
-      if (severable(i) && realTurns(i) >= minTurns) { cut = i; break; }
-      if (i === firstSpillable + 1) { if (severable(i)) cut = i; break; }
-    }
-  }
-
-  // NEVER SPILL THE CURRENT ASK.
-  //
-  // The tail budget walks BACKWARD accumulating bytes, and in an agent loop the
-  // last few messages are tool results — file reads, greps, build output. Those
-  // alone blow through 6,000 chars, so the cut lands AFTER the user's actual
-  // instruction and the instruction goes into the bound corpus instead of the
-  // forwarded window. It then only comes back if top-k recall happens to surface
-  // it against its own text, which is exactly the query it is least likely to
-  // match.
-  //
-  // OBSERVED: "sending 2/578 turns", and the model replying "I don't have a
-  // specific request to act on — your message came through empty", then
-  // re-reading the plan doc to work out where it was, every single turn. A loop
-  // that looks like amnesia and is actually us deleting the question.
-  //
-  // Retrieval is for CONTEXT. The ask itself is never context, and must survive
-  // any budget.
-  let lastUser = -1;
-  for (let i = msgs.length - 1; i > firstSpillable; i--) {
-    if (msgs[i].role === 'user' && msgText(msgs[i]).trim()) { lastUser = i; break; }
+    return null;
   }
-  if (lastUser > firstSpillable && cut > lastUser) cut = lastUser;
+  const { cut, firstSpillable } = adapted;
+  const stubbed = adapted.stubbed;
 
   const head = msgs.slice(0, firstSpillable);     // system block, always kept
   // EVERY FILE THE AGENT TOUCHED, AT FULL SIZE.
@@ -759,18 +613,9 @@ async function spillTranscript(body, log, req, stats) {
     ? `transcript prefix already bound (${bind.contextId}, ${keyKind}) — sending ${sent}/${msgs.length} turns`
     : `transcript prefix bound (${mb(bind.bytes)}MB → ${bind.contextId}, ${keyKind}) — sending ${sent}/${msgs.length} turns`);
 
-  // STUB BOUND FILE BODIES IN THE TAIL.
-  //
-  // Tests bind a 250k pile and send a one-line ask: 7x. Live Claude Code
-  // still forwards the last ~13 turns, which are Read/Bash tool_results of
-  // those same files. Sent ~= corpus, so counterfactualTokens > promptTokens
-  // barely fires and dollars stay ~1.2x with 5MB already bound. After a file
-  // is bound, drop its bytes from the forwarded tail (path + marker only).
-  // First-read results and non-file tool output stay verbatim. No disk I/O.
-  const stubbed = stubBoundFileResults(msgs, {
-    boundAbs: previouslyBoundAbs,
-    fromIndex: cut,
-  });
+  // Bound file bodies in the forwarded tail were stubbed inside applySpillCut
+  // (and maybe stubbed more if the tuner was below 10x). The adapt line is
+  // already logged there.
   if (stubbed.dropped) {
     log(`file-stub stubbed=${stubbed.stubbed} dropped=${stubbed.dropped}`);
   }
@@ -904,6 +749,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 */ } }
@@ -1321,62 +1169,77 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         }
       }
     if (rewritablePath(req.method, req.url)) {
-      const rw = await maybeRewriteModel(bodyBuf);
-      if (rw) {
-        // SAY WHETHER THE OVERRIDE IS ACTUALLY SET, and name it.
-        //
-        // This used to print "(OPENZOO_DEFAULT_MODEL overrides)" on EVERY
-        // rewrite whether or not the variable existed — a hint about a knob,
-        // phrased as a statement about this request. It cost a real incident:
-        // the proxy was restarted from a shell carrying
-        // OPENZOO_DEFAULT_MODEL=deepseek/deepseek-v4-pro-0813, so every
-        // claude-sonnet-5 ask was served by deepseek, and the log line looked
-        // exactly the same as it always had. deepseek matches the reasoning
-        // regex, so a 16-token safety classification became a 4,000-token
-        // reasoning generation — 11.5s, past the caller's timeout, and Claude
-        // Code reported "claude-sonnet-5 is temporarily unavailable".
-        const forced = process.env.OPENZOO_DEFAULT_MODEL;
-        log(forced
-          ? `model "${rw.from}" -> FORCED to ${forced} by OPENZOO_DEFAULT_MODEL (nearest match would have been ${rw.to})`
-          : `model "${rw.from}" is not on the zoo — nearest match ${rw.to}`);
-        bodyBuf = rw.body;
-      }
       try {
         let parsed = JSON.parse(bodyBuf.toString('utf8'));
         wantsStream = parsed?.stream === true || clientWantsStream;
-        // REASONING MODELS SPEND max_tokens ON THINKING FIRST.
+        // TINY CLASSIFY FIRST, ON THE ORIGINAL BODY.
         //
-        // The budget covers hidden reasoning AND the visible answer, so a
-        // caller that asks for 40 tokens because it wants a short answer often
-        // gets ZERO — the whole allowance went to reasoning and the completion
-        // truncated to an empty string. Measured across three families in one
-        // day: deepseek returned 0 chars at 8k and was fine at 24k; grok-4.6
-        // pinned ct at exactly its 16,000 budget with no visible output;
-        // sonnet-5 truncated a 600-token file mid-function because Anthropic's
-        // max_tokens covers thinking too.
-        //
-        // An empty completion is not an error — it bills normally and renders
-        // as a blank reply — so this fails silently and looks like the retrieval
-        // broke. It cost real debugging time tonight for exactly that reason.
-        // Multiply the allowance for known reasoning families and let callers
-        // keep asking for what they actually want back.
-        const REASONING = /(deepseek|grok|o[134](-|$)|reasoner|thinking|-pro\b|sol-pro|qwq)/i;
-        const mult = Number(process.env.OPENZOO_REASONING_MAX_TOKENS_X || 4);
-        const cap = Number(process.env.OPENZOO_REASONING_MAX_TOKENS_CAP || 32000);
-        const mdl = String(parsed?.model || '');
-        const mt = Number(parsed?.max_tokens);
-        // A MULTIPLIER ALONE IS NOT ENOUGH. 4x on a caller's 40 is 160, which is
-        // still nothing for a model that thinks first — measured, 2 of 3 runs
-        // still returned empty at 160. Reasoning needs an absolute floor, not a
-        // relative bump, so take whichever is larger.
-        const floor = Number(process.env.OPENZOO_REASONING_MIN_TOKENS || 4000);
-        if (mult > 1 && REASONING.test(mdl) && Number.isFinite(mt) && mt > 0 && mt < cap) {
-          const raised = Math.min(cap, Math.max(floor, Math.round(mt * mult)));
-          if (raised > mt) {
-            parsed.max_tokens = raised;
-            bodyBuf = Buffer.from(JSON.stringify(parsed));
-            log(`reasoning model ${mdl}: max_tokens ${mt} -> ${raised} (thinking shares the budget; OPENZOO_REASONING_MAX_TOKENS_X=1 disables)`);
+        // Claude Code auto-mode sends a 16-token yes/no to claude-sonnet-5
+        // before Bash/WebSearch. Two things used to eat that call:
+        //   1. OPENZOO_DEFAULT_MODEL rewrote it onto deepseek/grok;
+        //   2. the reasoning floor then raised 16 -> 4000.
+        // Measured: 11.5s, past the caller's timeout, "claude-sonnet-5 is
+        // 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)
+        // still get the 4000 floor � those still go blank without it.
+        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) {
+          // `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.
+          //
+          // This used to print "(OPENZOO_DEFAULT_MODEL overrides)" on EVERY
+          // rewrite whether or not the variable existed � a hint about a knob,
+          // phrased as a statement about this request. It cost a real incident:
+          // the proxy was restarted from a shell carrying
+          // OPENZOO_DEFAULT_MODEL=deepseek/deepseek-v4-pro-0813, so every
+          // claude-sonnet-5 ask was served by deepseek, and the log line looked
+          // exactly the same as it always had. deepseek matches the reasoning
+          // regex, so a 16-token safety classification became a 4,000-token
+          // reasoning generation � 11.5s, past the caller's timeout, and Claude
+          // Code reported "claude-sonnet-5 is temporarily unavailable".
+          // Tiny classify is pinned above and never reaches this path.
+          if (policy.to && policy.to !== policy.from) {
+            const forced = process.env.OPENZOO_DEFAULT_MODEL;
+            log(forced
+              ? `model "${policy.from}" -> FORCED to ${forced} by OPENZOO_DEFAULT_MODEL (nearest match would have been ${policy.to})`
+              : `model "${policy.from}" is not on the zoo � nearest match ${policy.to}`);
           }
+          // REASONING MODELS SPEND max_tokens ON THINKING FIRST.
+          //
+          // The budget covers hidden reasoning AND the visible answer, so a
+          // caller that asks for 40 tokens because it wants a short answer often
+          // gets ZERO � the whole allowance went to reasoning and the completion
+          // truncated to an empty string. Measured across three families in one
+          // day: deepseek returned 0 chars at 8k and was fine at 24k; grok-4.6
+          // pinned ct at exactly its 16,000 budget with no visible output;
+          // sonnet-5 truncated a 600-token file mid-function because Anthropic's
+          // max_tokens covers thinking too.
+          //
+          // An empty completion is not an error � it bills normally and renders
+          // as a blank reply � so this fails silently and looks like the retrieval
+          // broke. It cost real debugging time tonight for exactly that reason.
+          // Multiply the allowance for known reasoning families and let callers
+          // keep asking for what they actually want back.
+          //
+          // A MULTIPLIER ALONE IS NOT ENOUGH. 4x on a caller's 40 is 160, which is
+          // still nothing for a model that thinks first � measured, 2 of 3 runs
+          // still returned empty at 160. Reasoning needs an absolute floor, not a
+          // relative bump, so take whichever is larger.
+          if (policy.raised) {
+            log(`reasoning model ${parsed.model}: max_tokens ${policy.raisedFrom} -> ${policy.raisedTo} (thinking shares the budget; OPENZOO_REASONING_MAX_TOKENS_X=1 disables)`);
+          }
+        }
+        if (policy.tiny || policy.raised || (policy.to && policy.to !== policy.from)) {
+          bodyBuf = Buffer.from(JSON.stringify(parsed));
         }
         // Tell the agent what it is actually connected to — in band, where it
         // will read it, instead of leaving it to guess (and to chunk corpora
@@ -1398,10 +1261,12 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
           // advice nobody will read.
           //
           // Threshold is the same one the spill uses: below it there is no
-          // corpus and nothing the brief could help with.
-          const tiny = bodyBuf.length < BIND_MIN_CHARS
-            && Number(parsed?.max_tokens ?? 0) > 0
-            && Number(parsed?.max_tokens) <= 64;
+          // corpus and nothing the brief could help with. policy.tiny is
+          // that check on the ORIGINAL body, before the reasoning floor.
+          const tiny = policy.tiny
+            || (bodyBuf.length < BIND_MIN_CHARS
+              && Number(parsed?.max_tokens ?? 0) > 0
+              && Number(parsed?.max_tokens) <= 64);
           const briefed = tiny ? null : injectBrief(parsed, selfUrl);
           if (briefed) parsed = briefed;
           // SYSTEM MESSAGES BELONG AT THE FRONT, OR GOOGLE 400s.
@@ -1512,7 +1377,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,26 @@ 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 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,19 +541,33 @@ 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 instead of deleting the tool_use / tool_result pairing.
  *
  * `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,
   boundAbs,
   cwd = process.cwd(),
   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).
+  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.
+  budget = null,
+  fatChars = FAT_TOOL_CHARS,
 } = {}) {
   const absSet = boundAbs || boundAbsFromKeys(boundFiles);
-  if (!Array.isArray(msgs) || !absSet.size) {
+  const wantBudget = budget != null && Number.isFinite(Number(budget));
+  if (!Array.isArray(msgs) || (!absSet.size && !aggressive && !wantBudget)) {
     return { messages: msgs, stubbed: 0, dropped: 0 };
   }
 
@@ -556,6 +587,7 @@ export function stubBoundFileResults(msgs, {
     for (const raw of raws) {
       const hit = resolveBoundPath(raw, currentCwd, absSet);
       if (hit) resolved.push(hit);
+      else if (aggressive && raw) resolved.push(resolveReadablePath(raw, currentCwd) || raw);
     }
     if (!resolved.length || !id) return;
     stubIds.add(id);
@@ -581,35 +613,557 @@ export function stubBoundFileResults(msgs, {
     }
   }
 
-  if (!stubIds.size) return { messages: msgs, stubbed: 0, dropped: 0 };
+  const lastUser = lastUserAskIndex(msgs, firstSpillableIndex(msgs));
+  const fatLimit = Number.isFinite(Number(fatChars)) ? Number(fatChars) : FAT_TOOL_CHARS;
+
+  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 (aggressive && 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.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) };
     }
     if (!Array.isArray(m.content)) return m;
     let changed = false;
     const blocks = m.content.map((b) => {
-      if (b?.type !== 'tool_result' || !stubIds.has(b.tool_use_id)) return 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;
   });
+
+  // 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.
+  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.content)) continue;
+        let changed = false;
+        const blocks = m.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] = { ...m, content: blocks };
+      }
+      messages = next;
+    }
+  }
+
   return { messages, stubbed, dropped };
 }
 
+export const ADAPT_TARGET = 10;
+export const ADAPT_LOOSEN_AT = 20;
+
+export const KNOB_DEFAULTS = Object.freeze({
+  keepTail: 8,
+  minTurns: 6,
+  budget: 6000,
+  stubMore: false,
+});
+
+const KEEP_STEPS = [2, 3, 4, 6, 8, 12, 16];
+const TURNS_STEPS = [2, 3, 4, 6, 8, 12];
+const BUDGET_STEPS = [800, 1500, 2500, 4000, 6000, 9000, 12000, 18000, 24000];
+
+/** Flatten one Anthropic content block to text leCore can index. */
+export function blockText(b) {
+  if (typeof b === 'string') return b;
+  if (!b || typeof b !== 'object') return '';
+  if (b.type === 'text') return b.text || '';
+  if (b.type === 'tool_use') return `[tool_use ${b.name}] ${JSON.stringify(b.input ?? {})}`;
+  if (b.type === 'tool_result') {
+    const c = b.content;
+    return `[tool_result] ${typeof c === 'string' ? c : (Array.isArray(c) ? c.map(blockText).join('\n') : JSON.stringify(c ?? ''))}`;
+  }
+  if (b.type === 'thinking') return '';
+  return '';
+}
+
+export function msgText(m) {
+  const c = m?.content;
+  const body = typeof c === 'string' ? c : (Array.isArray(c) ? c.map(blockText).filter(Boolean).join('\n') : '');
+  return body ? `${(m.role || '?').toUpperCase()}: ${body}` : '';
+}
+
+/** Characters that actually ride in a forwarded message (content + tool_calls). */
+export function messageChars(m) {
+  if (!m) return 0;
+  let n = 0;
+  const c = m.content;
+  if (typeof c === 'string') n += c.length;
+  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 (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);
+    }
+  }
+  return n;
+}
+
+export function sliceChars(msgs, from = 0, to = undefined) {
+  if (!Array.isArray(msgs)) return 0;
+  const end = to == null ? msgs.length : to;
+  let n = 0;
+  for (let i = from; i < end && i < msgs.length; i++) n += messageChars(msgs[i]);
+  return n;
+}
+
+export function spillRatio(corpusChars, sentChars) {
+  const c = Number(corpusChars) || 0;
+  const s = Number(sentChars) || 0;
+  if (s <= 0) return c > 0 ? Infinity : 0;
+  return c / s;
+}
+
+function envNumber(key, fallback) {
+  const v = Number(process.env[key]);
+  return Number.isFinite(v) && v > 0 ? v : fallback;
+}
+
+export function envKnobs() {
+  return {
+    keepTail: envNumber('OPENZOO_KEEP_TAIL_MSGS', KNOB_DEFAULTS.keepTail),
+    minTurns: envNumber('OPENZOO_TAIL_MIN_TURNS', KNOB_DEFAULTS.minTurns),
+    budget: envNumber('OPENZOO_TAIL_MAX_CHARS', KNOB_DEFAULTS.budget),
+    stubMore: process.env.OPENZOO_STUB_MORE === '1',
+  };
+}
+
+export function adaptEnabled() {
+  return process.env.OPENZOO_ADAPT !== '0';
+}
+
+export function knobsFile(home = os.homedir()) {
+  return process.env.OPENZOO_KNOBS_PATH
+    || path.join(home, '.openzoo', 'knobs.json');
+}
+
+function clampInt(n, lo, hi, fallback) {
+  const v = Number(n);
+  if (!Number.isFinite(v)) return fallback;
+  return Math.min(hi, Math.max(lo, Math.round(v)));
+}
+
+export function sanitizeKnobs(raw = {}) {
+  if (!raw || typeof raw !== 'object') return { ...KNOB_DEFAULTS };
+  return {
+    keepTail: clampInt(raw.keepTail, KEEP_STEPS[0], KEEP_STEPS[KEEP_STEPS.length - 1], KNOB_DEFAULTS.keepTail),
+    minTurns: clampInt(raw.minTurns, TURNS_STEPS[0], TURNS_STEPS[TURNS_STEPS.length - 1], KNOB_DEFAULTS.minTurns),
+    budget: clampInt(raw.budget, BUDGET_STEPS[0], BUDGET_STEPS[BUDGET_STEPS.length - 1], KNOB_DEFAULTS.budget),
+    stubMore: Boolean(raw.stubMore),
+  };
+}
+
+export function loadKnobs(extra = {}) {
+  const file = extra.file || knobsFile(extra.home);
+  let raw;
+  try { raw = fs.readFileSync(file, 'utf8'); } catch { return { ok: false, reason: 'missing' }; }
+  let data;
+  try { data = JSON.parse(raw); } catch { return { ok: false, reason: 'corrupt' }; }
+  if (!data || typeof data !== 'object') return { ok: false, reason: 'corrupt' };
+  return { ok: true, knobs: sanitizeKnobs(data) };
+}
+
+export function persistKnobs(knobs, extra = {}) {
+  const file = extra.file || knobsFile(extra.home);
+  try {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const tmp = `${file}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(sanitizeKnobs(knobs)));
+    fs.renameSync(tmp, file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+let memoryKnobs = null;
+let lastAdaptAction = 'hold';
+let knobsLoaded = false;
+
+export function resetAdaptState(knobs = null) {
+  memoryKnobs = knobs ? sanitizeKnobs(knobs) : null;
+  lastAdaptAction = 'hold';
+  knobsLoaded = false;
+}
+
+export function lastAdapt() {
+  return lastAdaptAction;
+}
+
+export function getLiveKnobs(extra = {}) {
+  if (!adaptEnabled()) return envKnobs();
+  if (memoryKnobs) return { ...memoryKnobs };
+  if (!knobsLoaded) {
+    knobsLoaded = true;
+    const loaded = loadKnobs(extra);
+    if (loaded.ok) {
+      memoryKnobs = sanitizeKnobs({ ...envKnobs(), ...loaded.knobs });
+      return { ...memoryKnobs };
+    }
+  }
+  memoryKnobs = envKnobs();
+  return { ...memoryKnobs };
+}
+
+export function rememberKnobs(knobs, extra = {}) {
+  memoryKnobs = sanitizeKnobs(knobs);
+  if (extra.persist !== false) persistKnobs(memoryKnobs, extra);
+  return { ...memoryKnobs };
+}
+
+function nearestIndex(steps, value) {
+  let best = 0;
+  let dist = Infinity;
+  for (let i = 0; i < steps.length; i++) {
+    const d = Math.abs(steps[i] - value);
+    if (d < dist) { dist = d; best = i; }
+  }
+  return best;
+}
+
+export function tightenKnobs(knobs, { ratio, corpusChars, target = ADAPT_TARGET } = {}) {
+  const cur = sanitizeKnobs(knobs);
+  const gap = target / Math.max(Number(ratio) || 0.01, 0.01);
+  // Mild miss: one notch. Far below target (live 1–4x): jump toward the
+  // floor so a single recut can clear 10x. Always stub more on the way down.
+  const steps = gap > 1.5 ? 2 : 1;
+  const keepI = Math.max(0, nearestIndex(KEEP_STEPS, cur.keepTail) - steps);
+  const turnI = Math.max(0, nearestIndex(TURNS_STEPS, cur.minTurns) - steps);
+  let budget = cur.budget;
+  for (let i = 0; i < steps; i++) {
+    budget = BUDGET_STEPS[Math.max(0, nearestIndex(BUDGET_STEPS, budget) - 1)];
+  }
+  if (gap > 1.5 && Number.isFinite(corpusChars) && corpusChars > 0) {
+    const needSent = Math.floor(corpusChars / target);
+    if (needSent > 0) budget = Math.min(budget, Math.max(BUDGET_STEPS[0], needSent));
+    return sanitizeKnobs({
+      keepTail: KEEP_STEPS[0],
+      minTurns: TURNS_STEPS[0],
+      budget,
+      stubMore: true,
+    });
+  }
+  return sanitizeKnobs({
+    keepTail: KEEP_STEPS[keepI],
+    minTurns: TURNS_STEPS[turnI],
+    budget,
+    stubMore: true,
+  });
+}
+
+export function loosenKnobs(knobs) {
+  const cur = sanitizeKnobs(knobs);
+  const keepI = Math.min(KEEP_STEPS.length - 1, nearestIndex(KEEP_STEPS, cur.keepTail) + 1);
+  const turnI = Math.min(TURNS_STEPS.length - 1, nearestIndex(TURNS_STEPS, cur.minTurns) + 1);
+  const budI = Math.min(BUDGET_STEPS.length - 1, nearestIndex(BUDGET_STEPS, cur.budget) + 1);
+  return sanitizeKnobs({
+    keepTail: KEEP_STEPS[keepI],
+    minTurns: TURNS_STEPS[turnI],
+    budget: BUDGET_STEPS[budI],
+    stubMore: false,
+  });
+}
+
+function sameKnobs(a, b) {
+  return a.keepTail === b.keepTail
+    && a.minTurns === b.minTurns
+    && a.budget === b.budget
+    && Boolean(a.stubMore) === Boolean(b.stubMore);
+}
+
+function fmtRatio(ratio) {
+  if (!Number.isFinite(ratio)) return 'inf';
+  return String(Number(ratio.toFixed(2)));
+}
+
+function adaptLine({ action, ratio, knobs, target = ADAPT_TARGET }) {
+  if (action === 'hold') return `adapt hold ratio=${fmtRatio(ratio)}`;
+  return `adapt ratio=${fmtRatio(ratio)} target=${target} tail=${knobs.keepTail} budget=${knobs.budget}`;
+}
+
+/**
+ * Decide whether to shrink, loosen, or hold. Tighten recuts this request;
+ * loosen only remembers a safer notch for the NEXT one so we do not
+ * flip-flop every call after an overshoot.
+ */
+export function adaptTail({
+  ratio,
+  knobs,
+  lastAction = 'hold',
+  corpusChars,
+  target = ADAPT_TARGET,
+  loosenAt = ADAPT_LOOSEN_AT,
+} = {}) {
+  const cur = sanitizeKnobs(knobs);
+  if (!Number.isFinite(ratio)) {
+    return { action: 'hold', knobs: cur, recut: false, ratio, log: adaptLine({ action: 'hold', ratio, knobs: cur, target }) };
+  }
+  if (ratio < target) {
+    const next = tightenKnobs(cur, { ratio, corpusChars, target });
+    const changed = !sameKnobs(next, cur);
+    const action = changed ? 'tighten' : 'hold';
+    return { action, knobs: next, recut: changed, ratio, log: adaptLine({ action, ratio, knobs: next, target }) };
+  }
+  if (ratio > loosenAt && lastAction === 'hold') {
+    const next = loosenKnobs(cur);
+    const changed = !sameKnobs(next, cur);
+    const action = changed ? 'loosen' : 'hold';
+    return { action, knobs: next, recut: false, ratio, log: adaptLine({ action, ratio, knobs: next, target }) };
+  }
+  return { action: 'hold', knobs: cur, recut: false, ratio, log: adaptLine({ action: 'hold', ratio, knobs: cur, target }) };
+}
+
+function firstSpillableIndex(msgs) {
+  return msgs.findIndex((m) => m?.role !== 'system');
+}
+
+function lastUserAskIndex(msgs, firstSpillable) {
+  for (let i = msgs.length - 1; i > firstSpillable; i--) {
+    if (msgs[i]?.role === 'user' && msgText(msgs[i]).trim()) return i;
+  }
+  return -1;
+}
+
+function countRealTurns(msgs, from) {
+  let n = 0;
+  for (let i = from; i < msgs.length; i++) {
+    const r = msgs[i]?.role;
+    if (r === 'user' || r === 'assistant') n += 1;
+  }
+  return n;
+}
+
+function isSeverable(msgs, i, firstSpillable) {
+  if (i <= firstSpillable || i >= msgs.length) return false;
+  const prev = msgs[i - 1];
+  if (!prev) return false;
+  if (prev.role === 'assistant' && Array.isArray(prev.tool_calls) && prev.tool_calls.length) return false;
+  return msgs[i].role !== 'tool';
+}
+
+/**
+ * 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.
+ */
+export function cutTranscript(msgs, knobs = {}) {
+  const k = sanitizeKnobs({ ...envKnobs(), ...knobs });
+  if (!Array.isArray(msgs) || !msgs.length) {
+    return { cut: -1, firstSpillable: -1, lastUser: -1, knobs: k };
+  }
+  const firstSpillable = firstSpillableIndex(msgs);
+  if (firstSpillable < 0) return { cut: -1, firstSpillable: -1, lastUser: -1, knobs: k };
+
+  const keepTail = Math.min(k.keepTail, Math.max(2, Math.floor(msgs.length / 2)));
+  const minTurns = Math.max(2, k.minTurns);
+  const budget = k.budget;
+
+  let cut = -1;
+  for (let i = msgs.length - keepTail; i > firstSpillable; i--) {
+    if (isSeverable(msgs, i, firstSpillable)) { cut = i; break; }
+  }
+  if (cut <= firstSpillable) {
+    for (let i = msgs.length - 2; i > firstSpillable; i--) {
+      if (isSeverable(msgs, i, firstSpillable)) { cut = i; break; }
+    }
+  }
+  if (cut <= firstSpillable) {
+    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;
+    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 (tailStart > cut) cut = tailStart;
+
+  if (countRealTurns(msgs, cut) < minTurns) {
+    for (let i = cut - 1; i > firstSpillable; i--) {
+      if (isSeverable(msgs, i, firstSpillable) && countRealTurns(msgs, i) >= minTurns) { cut = i; break; }
+      if (i === firstSpillable + 1) { if (isSeverable(msgs, i, firstSpillable)) cut = i; break; }
+    }
+  }
+
+  const lastUser = lastUserAskIndex(msgs, firstSpillable);
+  if (lastUser > firstSpillable && cut > lastUser) cut = lastUser;
+
+  // Never shrink below 2 real turns when that would drop the ask — the ask
+  // always stays; expand earlier only if two turns exist and remain after it.
+  if (lastUser > firstSpillable && countRealTurns(msgs, cut) < 2) {
+    for (let i = cut - 1; i > firstSpillable; i--) {
+      if (isSeverable(msgs, i, firstSpillable) && countRealTurns(msgs, i) >= 2) { cut = i; break; }
+    }
+    if (cut > lastUser) cut = lastUser;
+  }
+
+  return { cut, firstSpillable, lastUser, knobs: k };
+}
+
+function stubForCut(msgs, cut, opts) {
+  return stubBoundFileResults(msgs, {
+    boundFiles: opts.boundFiles,
+    boundAbs: opts.boundAbs,
+    cwd: opts.cwd,
+    fromIndex: cut,
+    aggressive: Boolean(opts.aggressive),
+    budget: opts.budget,
+  });
+}
+
+/**
+ * Cut + stub, then retune knobs toward a >10x corpus/sent ratio in process
+ * memory. A miss recuts once this request. A huge overshoot loosens one
+ * notch for the next request only (no flip-flop). Env OPENZOO_ADAPT=0
+ * disables the tuner; env still seeds the initial knobs.
+ */
+export function applySpillCut(msgs, {
+  knobs,
+  corpusChars = 0,
+  boundFiles,
+  boundAbs,
+  cwd = process.cwd(),
+  log = () => {},
+  adapt = adaptEnabled(),
+  persist = false,
+  file,
+  home,
+} = {}) {
+  const persistOpts = { persist, file, home };
+  let k = sanitizeKnobs(knobs || getLiveKnobs(persistOpts));
+  let plan = cutTranscript(msgs, k);
+  const empty = {
+    cut: plan.cut,
+    firstSpillable: plan.firstSpillable,
+    lastUser: plan.lastUser,
+    knobs: k,
+    stubbed: { messages: msgs, stubbed: 0, dropped: 0 },
+    sentChars: 0,
+    prefixChars: 0,
+    ratio: 0,
+    action: 'hold',
+  };
+  if (plan.cut <= plan.firstSpillable) {
+    const sentChars = sliceChars(msgs, 0);
+    const corpus = Math.max(Number(corpusChars) || 0, sentChars);
+    return { ...empty, sentChars, ratio: spillRatio(corpus, sentChars) };
+  }
+
+  const measure = (cut, stubbed, knobsNow) => {
+    const prefixChars = sliceChars(msgs, plan.firstSpillable, cut);
+    const sentChars = sliceChars(stubbed.messages, cut);
+    const corpus = Math.max(Number(corpusChars) || 0, prefixChars);
+    return {
+      prefixChars,
+      sentChars,
+      corpusChars: corpus,
+      ratio: spillRatio(corpus, sentChars),
+      knobs: knobsNow,
+    };
+  };
+
+  let stubbed = stubForCut(msgs, plan.cut, { boundFiles, boundAbs, cwd, aggressive: k.stubMore, budget: k.budget });
+  let stats = measure(plan.cut, stubbed, k);
+  let action = 'hold';
+
+  if (adapt) {
+    const decision = adaptTail({
+      ratio: stats.ratio,
+      knobs: k,
+      lastAction: lastAdaptAction,
+      corpusChars: stats.corpusChars,
+    });
+    k = decision.knobs;
+    action = decision.action;
+    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 });
+        stats = measure(plan.cut, stubbed, k);
+      }
+    }
+    rememberKnobs(k, persistOpts);
+    lastAdaptAction = action;
+    log(adaptLine({ action, ratio: stats.ratio, knobs: k }));
+  }
+
+  return {
+    cut: plan.cut,
+    firstSpillable: plan.firstSpillable,
+    lastUser: plan.lastUser,
+    knobs: k,
+    stubbed,
+    sentChars: stats.sentChars,
+    prefixChars: stats.prefixChars,
+    ratio: stats.ratio,
+    action,
+  };
+}
+
 /** Session counters the HUD reads off /v1/info. */
 export function createSpillStats() {
   return {

package/package.json

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