openzoo 0.48.71 → 0.48.74

package/lib/proxy.js

@@ -13,9 +13,10 @@ import { tokenBalance } from './x402.js';
 import { evmTokenBalance } from './evm.js';
 import { bindCorpus, contextCacheDisabled, BIND_MIN_CHARS } from './hrr.js';
 import {
-  loadBoundChars, noteCorpusLedger, filesForCorpus, createSpillStats, corpusCharsForSend,
+  loadBoundChars, noteCorpusLedger, filesForCorpus, readFilesForCorpus, boundAbsFromKeys,
+  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';
@@ -330,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.
  *
@@ -374,11 +355,18 @@ async function spillTranscript(body, log, req, stats) {
   const msgs = Array.isArray(body?.messages) ? body.messages : null;
   if (!msgs?.length) return null;
 
-  // FILES FIRST. The cut/length gates below used to run before filesForCorpus,
-  // so a short agent turn that Read a file never bound it � and when the
-  // extract itself returned empty, nothing logged. Extract + log unconditionally.
-  const fileResult = filesForCorpus(msgs, { boundFiles, log });
-  const files = fileResult.text;
+  // PATHS FIRST, BYTES LATER. The cut/length gates below used to run before
+  // filesForCorpus, so a short agent turn that Read a file never bound it �
+  // and when the extract itself returned empty, nothing logged. Collect
+  // unconditionally, but only paths + cheap stat/mtime: a 2MB Read must not
+  // stall this turn. readdir + readFile + bindCorpus run after we return,
+  // via setImmediate, so the chat request goes first.
+  //
+  // Snapshot bound paths BEFORE collect so this turn's first-read files stay
+  // verbatim in the tail (not yet in the corpus for recall). Previously
+  // bound files get their tool_result bodies stubbed at return time.
+  const previouslyBoundAbs = boundAbsFromKeys(boundFiles);
+  const fileCollect = filesForCorpus(msgs, { boundFiles });
   const sessionId = req?.headers?.['x-claude-code-session-id']
     || req?.headers?.['x-session-id']
     || req?.headers?.['x-claude-session-id']
@@ -386,31 +374,46 @@ async function spillTranscript(body, log, req, stats) {
   let sessionKey = sessionId ? `sid:${sessionId}` : null;
 
   const ledgerOpts = () => ({ sessionKey, sessions: sessionLedger, boundFiles });
-  const bindFilesInBackground = (label) => {
-    if (!files) return;
+  const bindFilesInBackground = (label, { appendTo: forcedAppend, asAppend = false } = {}) => {
+    if (!fileCollect.pending.length) return;
     const known = (sessionKey && spillMemo.get(sessionKey))
       || (sessionKey && sessionLedger.get(sessionKey))
       || null;
-    const appendTo = known?.contextId || null;
-    void bindCorpus(files, {
-      appendTo,
-      onStage: (stage, info) => {
-        if (stage === 'binding') log(`binding ${info.bytes} bytes (${mb(info.bytes)}MB) of FILES (${label})`);
-      },
-    }).then((b) => {
-      if (!b?.contextId) return;
-      noteCorpusLedger(boundChars, {
-        contextId: b.contextId,
-        reused: Boolean(appendTo),
-        corpusChars: 0,
-        fileChars: files.length,
-        ...ledgerOpts(),
-      });
-      stats?.noteFileBind(fileResult.files, fileResult.bytes);
-      if (sessionKey && !spillMemo.has(sessionKey)) {
-        spillMemo.set(sessionKey, { corpus: '', contextId: b.contextId, hash: b.hash });
+    const appendTo = forcedAppend !== undefined ? forcedAppend : (known?.contextId || null);
+    setImmediate(() => {
+      let read;
+      try {
+        read = readFilesForCorpus(fileCollect, { boundFiles, log });
+      } catch (e) {
+        log(`${asAppend ? 'file append failed (corpus lags one turn)' : 'file bind failed'}: ${e.message}`);
+        return;
       }
-    }).catch((e) => log(`file bind failed: ${e.message}`));
+      if (!read.text) return;
+      void bindCorpus(read.text, {
+        appendTo,
+        onStage: (stage, info) => {
+          if (stage !== 'binding') return;
+          if (asAppend && appendTo) {
+            log(`appending ${info.bytes} bytes (${mb(info.bytes)}MB) of FILES to ${appendTo} (background)`);
+          } else {
+            log(`binding ${info.bytes} bytes (${mb(info.bytes)}MB) of FILES (${label})`);
+          }
+        },
+      }).then((b) => {
+        if (!b?.contextId) return;
+        noteCorpusLedger(boundChars, {
+          contextId: b.contextId,
+          reused: Boolean(appendTo),
+          corpusChars: 0,
+          fileChars: read.bytes,
+          ...ledgerOpts(),
+        });
+        stats?.noteFileBind(read.files, read.bytes);
+        if (sessionKey && !spillMemo.has(sessionKey)) {
+          spillMemo.set(sessionKey, { corpus: '', contextId: b.contextId, hash: b.hash });
+        }
+      }).catch((e) => log(`${asAppend ? 'file append failed (corpus lags one turn)' : 'file bind failed'}: ${e.message}`));
+    });
   };
 
   if (msgs.length < 6) {
@@ -418,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.
@@ -583,8 +460,9 @@ async function spillTranscript(body, log, req, stats) {
   // sitting on this machine. Binding it makes the corpus large immediately
   // instead of eventually, and makes the truncated read whole again.
   //
-  // Read-only, bounded, deduped by path+mtime. Path extraction + the file-bind
-  // log already ran at the top of this function (files / fileResult).
+  // Read-only, bounded, deduped by path+mtime. Path collection already ran at
+  // the top of this function (fileCollect.pending). Bytes + dir expansion
+  // happen in bindFilesInBackground after this turn is forwarded.
   //
   // FILES RIDE THE BACKGROUND, NEVER THE CRITICAL PATH.
   //
@@ -709,22 +587,15 @@ async function spillTranscript(body, log, req, stats) {
     reused: appended,
     corpusChars: corpus.length,
     deltaChars,
-    fileChars: files.length,
+    fileChars: 0,
     ...ledgerOpts(),
   });
   // APPEND THE FILES AFTER, off the clock. Fire-and-forget against the context
   // we just secured: this turn is already answerable without them, and the next
   // ask gets them for free. `boundFiles` already deduped by path:mtime, so this
   // uploads each version exactly once no matter how often the agent re-reads it.
-  if (files) {
-    stats?.noteFileBind(fileResult.files, fileResult.bytes);
-    void bindCorpus(files, {
-      appendTo: bind.contextId,
-      onStage: (stage, info) => {
-        if (stage === 'binding') log(`appending ${info.bytes} bytes (${mb(info.bytes)}MB) of FILES to ${bind.contextId} (background)`);
-      },
-    }).catch((e) => log(`file append failed (corpus lags one turn): ${e.message}`));
-  }
+  // Read + readdir are inside setImmediate � they must not run before send().
+  bindFilesInBackground('background', { appendTo: bind.contextId, asAppend: true });
   spillMemo.set(anchor, { corpus, contextId: bind.contextId, hash: bind.hash });
   if (spillMemo.size > 32) spillMemo.delete(spillMemo.keys().next().value);
   const sent = msgs.length - cut;
@@ -742,6 +613,13 @@ 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`);
 
+  // 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}`);
+  }
+
   // ADAPTIVE TOP-K. A fixed 32 chunks is what was actually eating the saving:
   // MEASURED on a 56,265-token corpus, top_k 32 handed 9,990 tokens back and
   // scored 2.45x, while 8 handed back 2,574 and scored 4.73x — same answer,
@@ -769,7 +647,7 @@ async function spillTranscript(body, log, req, stats) {
   const topK = Math.max(4, Math.min(12, Math.round(budget / 320)));
 
   return {
-    body: Buffer.from(JSON.stringify({ ...body, messages: [...head, ...msgs.slice(cut)] })),
+    body: Buffer.from(JSON.stringify({ ...body, messages: [...head, ...stubbed.messages.slice(cut)] })),
     topK,
     contextId: bind.contextId,
     hash: bind.hash,
@@ -1288,62 +1166,75 @@ 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) {
+          log(`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
@@ -1365,10 +1256,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.