openzoo 0.48.80 → 0.48.82

package/lib/proxy.js

@@ -14,7 +14,7 @@ import { evmTokenBalance } from './evm.js';
 import { bindCorpus, contextCacheDisabled, BIND_MIN_CHARS } from './hrr.js';
 import {
   loadBoundChars, noteCorpusLedger, filesForCorpus, readFilesForCorpus, boundAbsFromKeys,
-  createSpillStats, corpusCharsForSend, applySpillCut, msgText,
+  createSpillStats, corpusCharsForSend, applySpillCut, msgText, hudDollarX,
 } from './spill.js';
 import { rewritablePath, augmentModelList, ALIAS_IDS, rewriteChatModel, zooModelIds, CLASSIFY_MAX_TOKENS } from './models.js';
 import { forgetContext } from './contexts.js';
@@ -351,7 +351,7 @@ function replayPut(key, data, settle) {
  * severed at a plain `user` message — everything before one is self-contained.
  * A system message is never spilled: it is the operating contract, not history.
  */
-async function spillTranscript(body, log, req, stats) {
+async function spillTranscript(body, log, req, stats, extra = {}) {
   const msgs = Array.isArray(body?.messages) ? body.messages : null;
   if (!msgs?.length) return null;
 
@@ -364,7 +364,8 @@ async function spillTranscript(body, log, req, stats) {
   //
   // 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.
+  // bound files before the last ask may stub; remaining post-ask Read/Edit/
+  // Write / Bash-file bodies stay real (drop older rounds instead).
   const previouslyBoundAbs = boundAbsFromKeys(boundFiles);
   const fileCollect = filesForCorpus(msgs, { boundFiles });
   const sessionId = req?.headers?.['x-claude-code-session-id']
@@ -422,8 +423,9 @@ async function spillTranscript(body, log, req, stats) {
   }
 
   // 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.
+  // scores the HUD dollar multiple (spill direct/billed) and retunes
+  // keep/min-turns/budget (stubMore for SEARCH, not live file bodies)
+  // in process memory so this request recuts when the green x is under 10.
   // No restart. OPENZOO_ADAPT=0 freezes the env defaults. The ask always
   // stays; we never drop below 2 real user/assistant turns to delete it.
   const knownLedger = (sessionKey && spillMemo.get(sessionKey))
@@ -437,6 +439,8 @@ async function spillTranscript(body, log, req, stats) {
     boundAbs: previouslyBoundAbs,
     log,
     persist: true,
+    dollarX: extra.dollarX ?? hudDollarX(stats || {}),
+    lastSend: extra.lastSend,
   });
   if (adapted.cut <= adapted.firstSpillable) {
     bindFilesInBackground('no severable cut, files only');
@@ -628,9 +632,8 @@ 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.
+  // applySpillCut cut/stubbed the tail (post-ask file bodies stay real;
+  // search may stub). The adapt line is already logged there.
   if (stubbed.dropped) {
     log(`file-stub stubbed=${stubbed.stubbed} dropped=${stubbed.dropped}`);
   }
@@ -674,7 +677,7 @@ async function spillTranscript(body, log, req, stats) {
   };
 }
 
-async function maybeCacheCorpus(req, bodyBuf, log, stats) {
+async function maybeCacheCorpus(req, bodyBuf, log, stats, extra = {}) {
   if (contextCacheDisabled()) return null;
   if (req.method !== 'POST' || !(req.url || '').includes('/chat/completions')) return null;
   if (req.headers['x-hrr-context']) return null; // harness manages its own context
@@ -684,7 +687,7 @@ async function maybeCacheCorpus(req, bodyBuf, log, stats) {
     try {
       const body = JSON.parse(bodyBuf.toString('utf8'));
       if (Array.isArray(body?.messages) && body.messages.length) {
-        return spillTranscript(body, log, req, stats);
+        return spillTranscript(body, log, req, stats, extra);
       }
     } catch { /* not json */ }
     return null;
@@ -701,11 +704,11 @@ async function maybeCacheCorpus(req, bodyBuf, log, stats) {
   const oneShot = typeof last?.content === 'string'
     && last.content.length > BIND_MIN_CHARS
     && last.content.lastIndexOf('\n\n') >= BIND_MIN_CHARS;
-  if (!oneShot) return spillTranscript(body, log, req, stats);
+  if (!oneShot) return spillTranscript(body, log, req, stats, extra);
   const cut = last.content.lastIndexOf('\n\n');
   const corpus = last.content.slice(0, cut);
   const ask = last.content.slice(cut + 2).trim();
-  if (!ask || ask.length > 8000) return spillTranscript(body, log, req, stats);
+  if (!ask || ask.length > 8000) return spillTranscript(body, log, req, stats, extra);
 
   const bind = await bindCorpus(corpus, {
     onStage: (stage, info) => {
@@ -1396,7 +1399,15 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       try {
         // 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);
+        cached = await maybeCacheCorpus(req, bodyBuf, say, spill, {
+          lastSend: lastSpillSend?.sent,
+          dollarX: hudDollarX({
+            spillDirect: spill.spillDirect,
+            spillSpend: spill.spillSpend,
+            sessionDirect,
+            sessionSpent,
+          }),
+        });
       } catch (err) {
         log(`context cache skipped for this call: ${err.message}`);
       }

package/lib/spill.js

@@ -492,6 +492,38 @@ export function looksLikeFileView(command) {
   return sawView;
 }
 
+function toolFnName(c) {
+  return c?.function?.name || c?.name || '';
+}
+
+/**
+ * Read / Edit / Write (and file-view Bash). Bodies for these that remain
+ * after the last user ask must stay real — a `[bound, N chars]` placeholder
+ * in the live tail makes the model think Read is broken and cat files.
+ */
+export function isLiveFileTool(name, args = {}) {
+  const n = String(name || '');
+  if (/^(read|edit|write)/i.test(n)) return true;
+  if (/bash/i.test(n) && looksLikeFileView(args?.command)) return true;
+  return false;
+}
+
+/**
+ * Same number the HUD green `x` uses: this-call / running spill
+ * direct÷billed, else session-wide. Null when no dollar figure exists.
+ */
+export function hudDollarX({
+  spillDirect, spillSpend, sessionDirect, sessionSpent,
+} = {}) {
+  const billed = Number(spillSpend);
+  const direct = Number(spillDirect);
+  if (billed > 0 && Number.isFinite(direct)) return direct / billed;
+  const sessBilled = Number(sessionSpent);
+  const sessDirect = Number(sessionDirect);
+  if (sessBilled > 0 && Number.isFinite(sessDirect)) return sessDirect / sessBilled;
+  return null;
+}
+
 /** Tool result larger than this is "fat" — stub it in the forwarded tail. */
 export const FAT_TOOL_CHARS = 400;
 
@@ -645,8 +677,13 @@ function resolveBoundPath(raw, cwd, boundAbs) {
  * tool_calls / tool_use in that tail, plus tool results for those ids — not
  * every Read/Bash/Search after the last user ask. In-flight latest bodies
  * stay even when large. KEEP_TOOL_CHARS applies only to that last round so
- * a 461-byte Read survives a follow-up ask. Older rounds after the same
- * ask stub (bound / fat / over budget) and trim (keepTail) like 0.48.76.
+ * a 461-byte Read survives a follow-up ask.
+ *
+ * After the last user ask, remaining Read/Edit/Write / Bash-file bodies
+ * stay verbatim. Drop older post-ask rounds (trimRoundsAfterAsk) instead
+ * of rewriting them to `[bound, N chars]` — a placeholder in the live tail
+ * is 76-style blindness (model cats files). Fat WebSearch/Fetch in older
+ * kept rounds may still stub. stubMore tightens SEARCH, not live files.
  */
 export function stubBoundFileResults(msgs, {
   boundFiles,
@@ -675,12 +712,15 @@ export function stubBoundFileResults(msgs, {
   }
 
   const stubIds = new Set();
+  const fileIds = new Set();
+  const afterAskIds = new Set();
   const idPaths = new Map();
   let currentCwd = cwd;
 
   const noteCall = (c) => {
     const id = c?.id || c?.tool_call_id;
     const args = parseArgs(c?.function?.arguments ?? c?.arguments);
+    if (id && isLiveFileTool(toolFnName(c), args)) fileIds.add(id);
     const raws = [];
     collectStructuredPaths(args, raws);
     if (typeof args.command === 'string' && looksLikeFileView(args.command)) {
@@ -723,6 +763,15 @@ export function stubBoundFileResults(msgs, {
   const slimArgs = aggressive || wantBudget;
   let round = currentToolRound(msgs, { lastUser, fromIndex });
 
+  const markAfterAsk = (list) => {
+    afterAskIds.clear();
+    if (lastUser < 0 || !Array.isArray(list)) return;
+    for (let i = lastUser + 1; i < list.length; i++) {
+      for (const id of toolCallIds(list[i])) afterAskIds.add(id);
+    }
+  };
+  markAfterAsk(msgs);
+
   const stubFor = (id, n) => {
     const paths = idPaths.get(id);
     return paths?.length ? fileBoundStub(paths, n) : toolResultStub(n);
@@ -734,6 +783,8 @@ export function stubBoundFileResults(msgs, {
     if (id && round.inFlight && round.ids.has(id)) return false;
     // Last completed batch (ask follows): keep small bodies only.
     if (id && round.ids.has(id) && n < keepFloor) return false;
+    // Remaining post-ask file bodies stay real. Drop the round instead.
+    if (id && afterAskIds.has(id) && fileIds.has(id)) return false;
     if (stubIds.has(id)) return true;
     if (slimArgs && n >= fatLimit) return true;
     if (overBudget && n > 0) return true;
@@ -762,6 +813,7 @@ export function stubBoundFileResults(msgs, {
       firstSpillable: firstSpillableIndex(messages),
     });
     lastUser = lastUserAskIndex(messages, firstSpillableIndex(messages));
+    markAfterAsk(messages);
     round = currentToolRound(messages, { lastUser, fromIndex });
   }
 
@@ -877,9 +929,15 @@ export function stubBoundFileResults(msgs, {
       messages = next;
       used = sliceChars(messages, fromIndex);
       if (used > cap) {
-        // Only the un-severable last chain can still be huge (one assistant
-        // with hundreds of calls). Do not drop already-stubbed older rounds
-        // after the ask — the overage is often the protected latest batch.
+        // Still over: drop older post-ask rounds rather than rewriting
+        // remaining file bodies to `[bound]`. Then trim an un-severable
+        // last chain. Latest batch stays.
+        messages = trimRoundsAfterAsk(messages, {
+          fromIndex,
+          keepTail: 1,
+          lastUser,
+        });
+        lastUser = lastUserAskIndex(messages, firstSpillableIndex(messages));
         messages = trimUnseverablePairs(messages, {
           fromIndex,
           keepTail: 1,
@@ -895,6 +953,8 @@ export function stubBoundFileResults(msgs, {
 
 export const ADAPT_TARGET = 10;
 export const ADAPT_LOOSEN_AT = 20;
+/** lastSend growing past this while dollar x < target is a tighten signal. */
+export const LAST_SEND_TIGHTEN = 24;
 
 export const KNOB_DEFAULTS = Object.freeze({
   keepTail: 8,
@@ -1129,18 +1189,28 @@ function fmtRatio(ratio) {
   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}`;
+function adaptLine({ action, ratio, knobs, target = ADAPT_TARGET, dollarX } = {}) {
+  const d = Number(dollarX);
+  const hasD = Number.isFinite(d) && d > 0;
+  const via = hasD
+    ? `dollar=${fmtRatio(d)} chars=${fmtRatio(ratio)}`
+    : `ratio=${fmtRatio(ratio)}`;
+  if (action === 'hold') return `adapt hold ${via}`;
+  return `adapt ${via} 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.
+ * Decide whether to shrink, loosen, or hold.
+ *
+ * Score the HUD dollar multiple (direct/billed) when present. Char ratio
+ * is the fallback only. Tighten recuts this request. Loosen only when the
+ * scored metric is above loosenAt AND last action was hold — never loosen
+ * off a char-only overshoot while dollar x is in hand and below loosenAt.
  */
 export function adaptTail({
   ratio,
+  dollarX,
+  lastSend,
   knobs,
   lastAction = 'hold',
   corpusChars,
@@ -1148,22 +1218,31 @@ export function adaptTail({
   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 }) };
+  const dollar = Number(dollarX);
+  const hasDollar = Number.isFinite(dollar) && dollar > 0;
+  const score = hasDollar ? dollar : Number(ratio);
+  const sendN = Number(lastSend);
+  const sendGrowing = Number.isFinite(sendN) && sendN > LAST_SEND_TIGHTEN;
+  const line = (action, knobsNow) => adaptLine({
+    action, ratio, knobs: knobsNow, target, dollarX: hasDollar ? dollar : undefined,
+  });
+  if (!Number.isFinite(score)) {
+    return { action: 'hold', knobs: cur, recut: false, ratio, dollarX: hasDollar ? dollar : null, score, log: line('hold', cur) };
   }
-  if (ratio < target) {
-    const next = tightenKnobs(cur, { ratio, corpusChars, target });
+  // Dollar miss, or lastSend growing while dollar x is under target.
+  if (score < target || (hasDollar && dollar < target && sendGrowing)) {
+    const next = tightenKnobs(cur, { ratio: score, 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 }) };
+    return { action, knobs: next, recut: changed, ratio, dollarX: hasDollar ? dollar : null, score, log: line(action, next) };
   }
-  if (ratio > loosenAt && lastAction === 'hold') {
+  if (score > 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, knobs: next, recut: false, ratio, dollarX: hasDollar ? dollar : null, score, log: line(action, next) };
   }
-  return { action: 'hold', knobs: cur, recut: false, ratio, log: adaptLine({ action: 'hold', ratio, knobs: cur, target }) };
+  return { action: 'hold', knobs: cur, recut: false, ratio, dollarX: hasDollar ? dollar : null, score, log: line('hold', cur) };
 }
 
 function firstSpillableIndex(msgs) {
@@ -1354,10 +1433,11 @@ function stubForCut(msgs, cut, opts) {
 }
 
 /**
- * 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.
+ * Cut + stub, then retune knobs toward the HUD dollar multiple (direct /
+ * billed) when present, else corpus/sent. A miss recuts once this request
+ * (smaller keepTail; stubMore for SEARCH, not live file bodies). A dollar
+ * 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,
@@ -1370,6 +1450,8 @@ export function applySpillCut(msgs, {
   persist = false,
   file,
   home,
+  dollarX,
+  lastSend,
 } = {}) {
   const persistOpts = { persist, file, home };
   let k = sanitizeKnobs(knobs || getLiveKnobs(persistOpts));
@@ -1389,12 +1471,37 @@ export function applySpillCut(msgs, {
     // 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, {
+    let stubbed = stubForCut(msgs, stubFrom, {
       boundFiles, boundAbs, cwd, aggressive: k.stubMore, budget: k.budget, keepTail: k.keepTail,
     });
-    const sentChars = sliceChars(stubbed.messages, stubFrom);
+    let sentChars = sliceChars(stubbed.messages, stubFrom);
     const corpus = Math.max(Number(corpusChars) || 0, sentChars);
-    return { ...empty, stubbed, sentChars, ratio: spillRatio(corpus, sentChars) };
+    let ratio = spillRatio(corpus, sentChars);
+    let action = 'hold';
+    if (adapt) {
+      const thisSend = Math.max(0, stubbed.messages.length - stubFrom);
+      const decision = adaptTail({
+        ratio,
+        dollarX,
+        lastSend: Math.max(Number(lastSend) || 0, thisSend),
+        knobs: k,
+        lastAction: lastAdaptAction,
+        corpusChars: corpus,
+      });
+      k = decision.knobs;
+      action = decision.action;
+      if (decision.recut) {
+        stubbed = stubForCut(msgs, stubFrom, {
+          boundFiles, boundAbs, cwd, aggressive: k.stubMore, budget: k.budget, keepTail: k.keepTail,
+        });
+        sentChars = sliceChars(stubbed.messages, stubFrom);
+        ratio = spillRatio(corpus, sentChars);
+      }
+      rememberKnobs(k, persistOpts);
+      lastAdaptAction = action;
+      log(adaptLine({ action, ratio, knobs: k, dollarX }));
+    }
+    return { ...empty, knobs: k, stubbed, sentChars, ratio, action };
   }
 
   const measure = (cut, stubbed, knobsNow) => {
@@ -1417,8 +1524,11 @@ export function applySpillCut(msgs, {
   let action = 'hold';
 
   if (adapt) {
+    const thisSend = Math.max(0, stubbed.messages.length - plan.cut);
     const decision = adaptTail({
       ratio: stats.ratio,
+      dollarX,
+      lastSend: Math.max(Number(lastSend) || 0, thisSend),
       knobs: k,
       lastAction: lastAdaptAction,
       corpusChars: stats.corpusChars,
@@ -1436,7 +1546,7 @@ export function applySpillCut(msgs, {
     }
     rememberKnobs(k, persistOpts);
     lastAdaptAction = action;
-    log(adaptLine({ action, ratio: stats.ratio, knobs: k }));
+    log(adaptLine({ action, ratio: stats.ratio, knobs: k, dollarX }));
   }
 
   return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openzoo",
-  "version": "0.48.80",
+  "version": "0.48.82",
   "description": "Local x402-paying proxy + MCP server for openzoo.fun — point any OpenAI-compatible harness (Cursor, Claude Code, aider, SDKs) at localhost and it pays per call from a local burner wallet. Solana and Base rails live; Robinhood experimental.",
   "license": "MIT",
   "type": "module",