openzoo 0.48.78 → 0.48.80

package/lib/proxy.js

@@ -610,7 +610,10 @@ async function spillTranscript(body, log, req, stats) {
   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;
+  // Count the tail that is actually forwarded after stub/trim � older
+  // continue-turn rounds after the ask may have been dropped, so
+  // msgs.length - cut would keep lastSend growing with the raw pile.
+  const sent = Math.max(0, stubbed.messages.length - cut);
   // NAME THE KEY. A memo keyed on the wrong thing fails silently — it just
   // re-binds forever and collides sessions — so the log says which key was used.
   const keyKind = sessionId ? `sid ${String(sessionId).slice(0, 8)}` : 'content-anchor';

package/lib/spill.js

@@ -496,9 +496,10 @@ export function looksLikeFileView(command) {
 export const FAT_TOOL_CHARS = 400;
 
 /**
- * Bound-file matching used to stub any size, including a 461-byte Read the
- * model had just fetched. Stay under this floor unless we are over budget
- * *and* the result is not this turn's current tool round.
+ * Last-round bodies under this floor stay even after a follow-up ask
+ * (0.48.77: a 461-byte bound Read must remain visible). Older rounds use
+ * the 0.48.76 rules (bound / fat / over budget) whether or not they sit
+ * after the last user ask.
  */
 export const KEEP_TOOL_CHARS = 4096;
 
@@ -524,20 +525,22 @@ function toolCallIds(m) {
 }
 
 /**
- * Last assistant that issued tool_calls / tool_use, plus those ids.
+ * Most recent assistant tool_calls / Anthropic tool_use in the forwarded
+ * tail, plus those ids. Not "everything after the last user ask".
  *
- * Claude Code / OpenAI put *this turn's* Read/Bash/WebSearch results in
- * `role:tool` (or tool_result blocks) AFTER the last user ask. Those are
- * in-flight — the model's current eyes — and must never be stubbed, even
- * when large. A completed round (tools, then a follow-up ask) may still
- * be stubbed; that is the 0.48.76 storm savings. The last round's small
- * bodies still use KEEP_TOOL_CHARS so a 461-byte Read survives.
+ * A long continue / ultracode turn parks the last user ask early and then
+ * stacks Read/Bash/WebSearch rounds after it. Only the latest batch is
+ * this turn's eyes — even a 461-byte Read, even a fat WebSearch. Older
+ * batches in that same tail stub/trim under the 0.48.76 rules. When the
+ * ask follows the last batch, KEEP_TOOL_CHARS still keeps that last
+ * round's small bodies (0.48.77) while fat completed rounds may stub.
  */
-export function currentToolRound(msgs, { lastUser = -1 } = {}) {
+export function currentToolRound(msgs, { lastUser = -1, fromIndex = 0 } = {}) {
   let index = -1;
   const ids = new Set();
   if (!Array.isArray(msgs)) return { index, ids, inFlight: false };
-  for (let i = 0; i < msgs.length; i++) {
+  const start = Math.max(0, Number(fromIndex) || 0);
+  for (let i = start; i < msgs.length; i++) {
     const here = toolCallIds(msgs[i]);
     if (!here.length) continue;
     index = i;
@@ -638,12 +641,12 @@ function resolveBoundPath(raw, cwd, boundAbs) {
  *
  * `fromIndex` limits the rewrite to the forwarded tail so the spilled prefix
  * that becomes the conversation corpus is unchanged. The last user ask is
- * never rewritten. The current tool round — last assistant with tool_calls
- * / tool_use and every matching role:tool / tool_result — is never rewritten
- * when that assistant sits after the last user ask (this turn's eyes).
- * Bodies under KEEP_TOOL_CHARS on that last round also stay, even when the
- * ask follows the results, so a 461-byte Read is not replaced with
- * `[bound, 461 chars]`.
+ * never rewritten. The current tool round is only the most recent assistant
+ * 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.
  */
 export function stubBoundFileResults(msgs, {
   boundFiles,
@@ -718,7 +721,7 @@ export function stubBoundFileResults(msgs, {
   const fatLimit = Number.isFinite(Number(fatChars)) ? Number(fatChars) : FAT_TOOL_CHARS;
   const keepFloor = KEEP_TOOL_CHARS;
   const slimArgs = aggressive || wantBudget;
-  let round = currentToolRound(msgs, { lastUser });
+  let round = currentToolRound(msgs, { lastUser, fromIndex });
 
   const stubFor = (id, n) => {
     const paths = idPaths.get(id);
@@ -727,10 +730,13 @@ export function stubBoundFileResults(msgs, {
 
   const shouldStubBody = (id, n, { overBudget = false } = {}) => {
     if (!n || isStubText(typeof n === 'number' ? '' : n)) return false;
+    // Latest in-flight batch (after the ask): never stub, even if fat.
     if (id && round.inFlight && round.ids.has(id)) return false;
-    if (n < keepFloor && (!overBudget || (id && 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;
     if (stubIds.has(id)) return true;
     if (slimArgs && n >= fatLimit) return true;
+    if (overBudget && n > 0) return true;
     return false;
   };
 
@@ -738,16 +744,25 @@ export function stubBoundFileResults(msgs, {
   let dropped = 0;
   let messages = msgs;
 
-  // keepTail votes here because cutTranscript cannot move inside the chain.
+  // keepTail votes here because cutTranscript cannot move inside the chain
+  // *or* past the last user ask. A continue turn stacks severable
+  // assistant+result rounds after that ask; trim those older rounds first
+  // so lastSend cannot grow to hundreds of fully-billed messages.
   if (wantKeep) {
+    messages = trimRoundsAfterAsk(messages, {
+      fromIndex,
+      keepTail: Number(keepTail),
+      lastUser,
+    });
+    lastUser = lastUserAskIndex(messages, firstSpillableIndex(messages));
     messages = trimUnseverablePairs(messages, {
       fromIndex,
       keepTail: Number(keepTail),
       lastUser,
-      firstSpillable,
+      firstSpillable: firstSpillableIndex(messages),
     });
     lastUser = lastUserAskIndex(messages, firstSpillableIndex(messages));
-    round = currentToolRound(messages, { lastUser });
+    round = currentToolRound(messages, { lastUser, fromIndex });
   }
 
   const skipSlimCalls = (i) => round.inFlight && i === round.index;
@@ -862,6 +877,9 @@ 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.
         messages = trimUnseverablePairs(messages, {
           fromIndex,
           keepTail: 1,
@@ -1176,6 +1194,35 @@ function isSeverable(msgs, i, firstSpillable) {
   return msgs[i].role !== 'tool';
 }
 
+/**
+ * cutTranscript pins `cut` at the last user ask, so every later tool round
+ * on a continue / ultracode turn used to ride in the forwarded tail. Keep
+ * the newest `keepTail` complete assistant(tool_calls)+results rounds after
+ * that ask and drop the older ones. Pairing stays valid; the ask stays;
+ * the latest round is never dropped.
+ */
+export function trimRoundsAfterAsk(msgs, {
+  fromIndex = 0,
+  keepTail = 1,
+  lastUser = -1,
+} = {}) {
+  if (!Array.isArray(msgs) || lastUser < 0) return msgs;
+  const keep = Math.max(1, Math.round(Number(keepTail) || 1));
+  const start = Math.max(fromIndex, lastUser + 1);
+  const starts = [];
+  for (let i = start; i < msgs.length; i++) {
+    if (toolCallIds(msgs[i]).length) starts.push(i);
+  }
+  if (starts.length <= keep) return msgs;
+  const keepFrom = starts[starts.length - keep];
+  const out = [];
+  for (let i = 0; i < msgs.length; i++) {
+    if (i > lastUser && i < keepFrom) continue;
+    out.push(msgs[i]);
+  }
+  return out;
+}
+
 /**
  * On an un-severable assistant(tool_calls)+results chain, keepTail cannot
  * move `cut`. Drop older complete pairs (rewrite tool_calls, drop their

package/package.json

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