openzoo 0.48.70 → 0.48.72

package/lib/launch.js

@@ -230,11 +230,16 @@ export async function launchClaude(argv) {
         + 'const sp=j.spilled||{};'
         + 'const tk=Number(sp.tokensApprox)||0;'
         + 'const ht=tk>=1e6?(tk/1e6).toFixed(1)+"M":tk>=1e3?Math.round(tk/1e3)+"k":String(tk);'
+        + 'const paid=Number(j.paidCalls)||0;'
         + 'const sc=Number(sp.calls)||0;'
         + 'const fb=Number(sp.fileBinds)||0;'
+        + 'const rb=Number(sp.reusedBinds)||0;'
+        + 'const ls=sp.lastSend||{};'
         + 'const bits=[];'
-        + 'if(sc||j.paidCalls)bits.push(sc+" spilled");'
-        + 'if(fb||sc)bits.push(fb+" filebind");'
+        + 'bits.push("spilled "+sc+"/"+paid+" calls");'
+        + 'if(rb)bits.push(rb+" reused");'
+        + 'bits.push(fb+" filebind");'
+        + 'if(ls.sent!=null&&ls.msgs!=null)bits.push("sending "+ls.sent+"/"+ls.msgs);'
         + 'if(tk)bits.push(ht+" tok offloaded");'
         + 'const spill=bits.length?("  \\u00b7 "+bits.join("  \\u00b7 ")):"";'
         // "how can I easily see what credit i'm left" — asked by a user who

package/lib/proxy.js

@@ -13,7 +13,8 @@ import { tokenBalance } from './x402.js';
 import { evmTokenBalance } from './evm.js';
 import { bindCorpus, contextCacheDisabled, BIND_MIN_CHARS } from './hrr.js';
 import {
-  loadBoundChars, noteCorpusLedger, filesForCorpus, createSpillStats,
+  loadBoundChars, noteCorpusLedger, filesForCorpus, readFilesForCorpus, boundAbsFromKeys,
+  stubBoundFileResults, createSpillStats, corpusCharsForSend,
 } from './spill.js';
 import { maybeRewriteModel, rewritablePath, augmentModelList, ALIAS_IDS } from './models.js';
 import { forgetContext } from './contexts.js';
@@ -374,11 +375,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 +394,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 ${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) {
@@ -583,8 +606,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 +733,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 ${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 +759,22 @@ 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,
+  });
+  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,13 +802,15 @@ 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,
     corpus,
     reused: bind.reused,
     savedBytes: bind.bytes,
+    sent,
+    msgs: msgs.length,
   };
 }
 
@@ -837,6 +872,8 @@ async function maybeCacheCorpus(req, bodyBuf, log, stats) {
     corpus,
     reused: bind.reused,
     savedBytes: bind.bytes,
+    sent: 1,
+    msgs: msgs.length,
   };
 }
 
@@ -900,6 +937,7 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
   // instead of re-sent, and nothing measured it — the status line showed spend
   // and call count, which is the cost side with none of the benefit.
   const spill = createSpillStats();
+  let lastSpillSend = null;
   // Spend/direct for ONLY the calls that spilled. The session-wide savingX
   // averages these with every small turn that had nothing to offload, so it
   // slides toward 1.0 as a conversation grows — which reads as the mechanism
@@ -1044,13 +1082,14 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
           reachedVia: viaTunnel ? 'public tunnel' : 'localhost',
           publicTunnel: tunnelGate?.publicUrl ? `${tunnelGate.publicUrl}/v1` : null,
           servedRequests,
-          spilled: {
-            ...spill.snapshot(),
-            // ~4 chars/token is the usual rough rule; this is the context that
-            // did NOT ride upstream on those calls, which is the number the
-            // saving is actually made of.
-            boundChars: [...boundChars.values()].reduce((a, b) => a + b, 0),
-          },
+          spilled: (() => {
+            const ledgerTotal = [...boundChars.values()].reduce((a, b) => a + b, 0);
+            return {
+              ...spill.snapshot({ boundChars: ledgerTotal }),
+              boundChars: ledgerTotal,
+              lastSend: lastSpillSend,
+            };
+          })(),
           spendUsd: sessionSpent,
           creditUsd,
           // WHAT THE SAME CALLS WOULD HAVE COST DIRECT. Spend on its own is a
@@ -1504,7 +1543,8 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       if (cached) {
         spill.noteSpill({ corpusChars: cached.corpus?.length || 0, reused: cached.reused });
         didSpill = true;
-        result = await send(cached.body, cached.contextId, cached.topK, boundChars.get(cached.contextId) || cached.corpus?.length);
+        if (cached.sent != null) lastSpillSend = { sent: cached.sent, msgs: cached.msgs };
+        result = await send(cached.body, cached.contextId, cached.topK, corpusCharsForSend(boundChars, cached.contextId, cached.corpus?.length));
         // Sidecar wiped between runs: the gateway 404s BEFORE the 402 (nothing
         // paid). Never fail on a stale manifest — re-bind once and retry.
         if (result.response.status === 404) {
@@ -1513,7 +1553,7 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
             log('bound context is gone on the zoo — re-binding once...');
             forgetContext(config.apiBase, cached.hash);
             const rebound = await bindCorpus(cached.corpus, { force: true });
-            result = await send(cached.body, rebound.contextId, cached.topK, boundChars.get(rebound.contextId) || cached.corpus?.length);
+            result = await send(cached.body, rebound.contextId, cached.topK, corpusCharsForSend(boundChars, rebound.contextId, cached.corpus?.length));
           } else {
             res.writeHead(404, { 'content-type': 'application/json' });
             res.end(text);

package/lib/spill.js

@@ -94,24 +94,28 @@ export function accumulateBoundChars(boundChars, contextId, chars, opts = {}) {
 }
 
 /**
- * Apply the bind/append/file rule in one place so spillTranscript and the
- * tests cannot drift.
+ * Conversation chars use Math.max so a stale smaller ledger (the 34056
+ * files-only row) cannot cap a later, larger prefix. New file bytes add on top.
  *
- * First bind initializes to the conversation corpus; each append adds the
- * delta; file bytes are added on top either way.
+ *   next = max(prev, corpusChars) + fileChars
  */
 export function noteCorpusLedger(boundChars, {
-  contextId, reused, corpusChars = 0, deltaChars = 0, fileChars = 0, ...opts
+  contextId, corpusChars = 0, fileChars = 0, ...opts
 } = {}) {
   if (!contextId) return 0;
-  if (reused) {
-    if (deltaChars) accumulateBoundChars(boundChars, contextId, deltaChars, { ...opts, persist: false });
-  } else {
-    accumulateBoundChars(boundChars, contextId, corpusChars, { ...opts, init: true, persist: false });
+  const prev = boundChars.get(contextId) || 0;
+  const next = Math.max(prev, Number(corpusChars) || 0) + (Number(fileChars) || 0);
+  boundChars.set(contextId, next);
+  if (opts.sessionKey && opts.sessions) {
+    opts.sessions.set(opts.sessionKey, { contextId, chars: next });
   }
-  if (fileChars) accumulateBoundChars(boundChars, contextId, fileChars, { ...opts, persist: false });
   persistBoundChars(boundChars, opts);
-  return boundChars.get(contextId) || 0;
+  return next;
+}
+
+/** send() must not let `stale || thisTurn` pick the smaller number. */
+export function corpusCharsForSend(boundChars, contextId, thisTurn) {
+  return Math.max(boundChars.get(contextId) || 0, thisTurn || 0);
 }
 
 /** Expand ~ and resolve relative paths against cwd. Returns null if unusable. */
@@ -144,92 +148,164 @@ function parseArgs(args) {
   return {};
 }
 
-function collectFromValue(value, out, depth) {
-  if (depth > 6 || value == null) return;
-  if (typeof value === 'string') {
-    if (looksLikePath(value)) out.push(value);
-    const t = value.trim();
-    if ((t.startsWith('{') || t.startsWith('[')) && t.length < 100_000) {
-      try { collectFromValue(JSON.parse(t), out, depth + 1); } catch { /* not json */ }
-    }
-    return;
+function collectStructuredPaths(args, out) {
+  if (!args || typeof args !== 'object') return;
+  for (const k of PATH_KEYS) {
+    if (typeof args[k] === 'string' && args[k]) out.push(args[k]);
   }
-  if (Array.isArray(value)) {
-    for (const x of value) collectFromValue(x, out, depth + 1);
-    return;
+  for (const k of PATH_ARRAY_KEYS) {
+    if (!Array.isArray(args[k])) continue;
+    for (const x of args[k]) {
+      if (typeof x === 'string') out.push(x);
+      else if (x && typeof x === 'object') collectStructuredPaths(x, out);
+    }
   }
-  if (typeof value !== 'object') return;
-  for (const [k, v] of Object.entries(value)) {
-    if (PATH_KEYS.has(k) && typeof v === 'string' && v) out.push(v);
-    else if (PATH_ARRAY_KEYS.has(k) && Array.isArray(v)) {
-      for (const x of v) {
-        if (typeof x === 'string') out.push(x);
-        else collectFromValue(x, out, depth + 1);
-      }
-    } else if (k === 'input' || k === 'arguments' || k === 'params' || k === 'parameters') {
-      collectFromValue(typeof v === 'string' ? parseArgs(v) : v, out, depth + 1);
+}
+
+const CWD_HINT = /(?:current working directory is[:\s]+|<cwd>\s*|cwd:\s+)([^\s<]+)/i;
+
+export function parseCwdHint(text) {
+  if (typeof text !== 'string' || !text) return null;
+  const m = text.match(CWD_HINT);
+  if (!m) return null;
+  const p = m[1].trim();
+  return path.isAbsolute(p) ? p : null;
+}
+
+/**
+ * Pull path-like tokens out of a Bash `command` string.
+ * `head -80 programs/README.md` and `cat /abs/file` both count; bare `ls` does not.
+ */
+export function extractBashPaths(command, cwd = process.cwd()) {
+  const found = [];
+  if (typeof command !== 'string' || !command) return { paths: found, cwd };
+  let localCwd = cwd;
+  for (const part of command.split(/(?:&&|\|\||;|\n)/)) {
+    const cd = part.match(/^\s*cd\s+(?:\/[dD]\s+)?(['"]?)(.+?)\1\s*$/);
+    if (cd) {
+      const dest = resolveReadablePath(cd[2].trim(), localCwd);
+      if (dest) localCwd = dest;
+      continue;
+    }
+    for (const m of part.matchAll(/(['"])([^'"]+)\1/g)) {
+      const t = m[2].trim();
+      if (looksLikePath(t) || path.isAbsolute(t)) found.push({ raw: t, cwd: localCwd });
+    }
+    for (const tok of part.split(/\s+/)) {
+      const t = tok.replace(/^[`'"]|[`'"]$/g, '');
+      if (!t || t.startsWith('-') || t.startsWith('$') || t === '.' || t === '..') continue;
+      if (looksLikePath(t) || path.isAbsolute(t)) found.push({ raw: t, cwd: localCwd });
     }
   }
+  return { paths: found, cwd: localCwd };
 }
 
 /**
- * Pull file paths out of a transcript that may still be Anthropic-shaped,
- * already translated to OpenAI tool_calls, or a mix (Responses → chat).
- *
- * Structured fields only — never walks tool_result *bodies*, which are file
- * contents and would harvest every import path in the source.
+ * Live Claude Code msgs are OpenAI-shaped (spill runs AFTER anthropicToOpenAI).
+ * Read/Edit/Write land on tool_calls[].function.arguments as a JSON string
+ * {file_path:"/abs/..."}. Bash is {command:"head -80 programs/README.md"}.
+ * Do not expect Read tool_result to carry the path. Do not harvest import
+ * paths out of tool_result bodies.
  */
-export function extractFilePaths(msgs) {
-  const raw = [];
-  if (!Array.isArray(msgs)) return [];
+export function extractFileCandidates(msgs, { cwd = process.cwd() } = {}) {
+  const structured = [];
+  const bash = [];
+  let currentCwd = cwd;
+  if (!Array.isArray(msgs)) return { structured, bash, cwd: currentCwd };
   for (const m of msgs) {
     if (!m || typeof m !== 'object') continue;
-    const blocks = Array.isArray(m.content) ? m.content : [];
-    for (const b of blocks) {
-      if (!b || typeof b !== 'object') continue;
-      if (b.input) collectFromValue(b.input, raw, 0);
-      for (const k of PATH_KEYS) {
-        if (typeof b[k] === 'string') raw.push(b[k]);
-      }
-      // tool_result: only structured content, never a long body string
-      if (b.type === 'tool_result' && b.content && typeof b.content === 'object') {
-        collectFromValue(b.content, raw, 0);
-      } else if (b.type === 'tool_result' && typeof b.content === 'string' && b.content.length < 512 && looksLikePath(b.content)) {
-        raw.push(b.content.trim());
-      }
+    if (m.role === 'tool' && typeof m.content === 'string') {
+      const hint = parseCwdHint(m.content);
+      if (hint) currentCwd = hint;
     }
     const calls = [
       ...(Array.isArray(m.tool_calls) ? m.tool_calls : []),
       ...(m.function_call ? [m.function_call] : []),
     ];
     for (const c of calls) {
-      collectFromValue(parseArgs(c?.function?.arguments ?? c?.arguments), raw, 0);
-      if (c?.input) collectFromValue(c.input, raw, 0);
-      if (typeof c?.function?.name === 'string' && c.function.arguments == null && typeof c.name === 'string') {
-        collectFromValue(c, raw, 0);
+      const args = parseArgs(c?.function?.arguments ?? c?.arguments);
+      const fromArgs = [];
+      collectStructuredPaths(args, fromArgs);
+      for (const raw of fromArgs) structured.push({ raw, cwd: currentCwd });
+      if (typeof args.command === 'string') {
+        const got = extractBashPaths(args.command, currentCwd);
+        for (const p of got.paths) bash.push({ ...p, bash: true });
+        currentCwd = got.cwd;
+      }
+    }
+    // Harmless leftover: pre-conversion Anthropic tool_use. Live Claude Code
+    // never has this by the time spillTranscript runs.
+    const blocks = Array.isArray(m.content) ? m.content : [];
+    for (const b of blocks) {
+      if (b?.input) {
+        const fromInput = [];
+        collectStructuredPaths(b.input, fromInput);
+        for (const raw of fromInput) structured.push({ raw, cwd: currentCwd });
+        if (typeof b.input.command === 'string') {
+          const got = extractBashPaths(b.input.command, currentCwd);
+          for (const p of got.paths) bash.push({ ...p, bash: true });
+          currentCwd = got.cwd;
+        }
       }
     }
   }
+  return { structured, bash, cwd: currentCwd };
+}
+
+export function extractFilePaths(msgs, opts) {
+  const { structured, bash } = extractFileCandidates(msgs, opts);
   const seen = new Set();
   const out = [];
-  for (const p of raw) {
-    if (typeof p !== 'string') continue;
-    const t = p.trim();
-    if (!t || seen.has(t)) continue;
-    seen.add(t);
-    out.push(t);
+  for (const item of [...structured, ...bash]) {
+    const t = typeof item === 'string' ? item : item?.raw;
+    if (typeof t !== 'string') continue;
+    const s = t.trim();
+    if (!s || seen.has(s)) continue;
+    seen.add(s);
+    out.push(s);
   }
   return out;
 }
 
+const SKIP_DIR_NAMES = new Set(['node_modules', '.git', 'dist', 'build', '__pycache__', '.venv', 'target']);
+
+function fileBindLog({ kept, bytes, enoent, cap, dir, rel, bash }) {
+  return `file-bind kept=${kept} bytes=${bytes} skip enoent=${enoent} cap=${cap} dir=${dir} rel=${rel} bash=${bash}`;
+}
+
+function emptyFileBind({ reason = 'none-kept', ...extra } = {}) {
+  return {
+    text: '',
+    files: 0,
+    bytes: 0,
+    pending: [],
+    kept: 0,
+    enoent: 0,
+    cap: 0,
+    dir: 0,
+    rel: 0,
+    bash: 0,
+    reason,
+    ...extra,
+  };
+}
+
 /**
- * Read every new file the agent touched and return the corpus slice to bind.
+ * Request-path filebind: collect paths + cheap stat/mtime only.
+ *
+ * Live path is OpenAI tool_calls (Read/Edit/Write + Bash command). Relative
+ * paths resolve against cwd / last "current working directory is …" hint.
  *
- * Read-only, size-capped, path+mtime deduped. Failures never throw — this
- * runs on the request path.
+ * MUST NOT read file contents and MUST NOT readdir children. A 2MB Read
+ * (or a directory the agent listed) used to stall the chat turn here.
+ * Bytes, directory expansion, and bindCorpus belong in readFilesForCorpus,
+ * which the proxy runs after the turn is already on the wire.
  *
- * Always reports `file-bind N files / X bytes` or `file-bind 0 because …`
- * so a silent empty extract cannot hide again.
+ * Dedupes on path+mtime into `boundFiles`, applies the size cap, and
+ * reserves directory keys so the same tree is not re-queued every turn.
+ * The `file-bind kept=N bytes=B …` line is logged here only when there is
+ * nothing to read (disabled / none-kept) — otherwise readFilesForCorpus
+ * fills bytes after the background read, never on the hot path.
  */
 export function filesForCorpus(msgs, {
   boundFiles,
@@ -238,54 +314,300 @@ export function filesForCorpus(msgs, {
   disabled = process.env.OPENZOO_BIND_FILES === '0',
   log = () => {},
   statSync = (p) => fs.statSync(p),
-  readFileSync = (p) => fs.readFileSync(p, 'utf8'),
 } = {}) {
   if (disabled) {
-    log('file-bind 0 because OPENZOO_BIND_FILES=0');
-    return { text: '', files: 0, bytes: 0, reason: 'disabled' };
-  }
-  const paths = extractFilePaths(msgs);
-  if (!paths.length) {
-    log('file-bind 0 because no file paths in tool_use / tool_calls');
-    return { text: '', files: 0, bytes: 0, reason: 'no-paths' };
+    const empty = emptyFileBind({ reason: 'disabled' });
+    log(fileBindLog(empty));
+    return empty;
   }
+  const { structured, bash } = extractFileCandidates(msgs, { cwd });
+  const candidates = [
+    ...structured.map((p) => ({ ...p, bash: false })),
+    ...bash.map((p) => ({ ...p, bash: true })),
+  ];
+  const skip = { enoent: 0, cap: 0, dir: 0, rel: 0 };
   const seen = new Set();
+  const pending = [];
+
+  const queue = (abs) => {
+    if (!abs || seen.has(abs)) return;
+    seen.add(abs);
+    let st;
+    try { st = statSync(abs); } catch { skip.enoent += 1; return; }
+    if (st.isDirectory()) {
+      skip.dir += 1;
+      const key = `${abs}:${st.mtimeMs}`;
+      if (boundFiles?.has(key)) return;
+      boundFiles?.add(key);
+      pending.push({ abs, kind: 'dir' });
+      return;
+    }
+    if (!st.isFile()) { skip.enoent += 1; return; }
+    if (st.size > cap) { skip.cap += 1; return; }
+    const key = `${abs}:${st.mtimeMs}`;
+    if (boundFiles?.has(key)) return;
+    boundFiles?.add(key);
+    pending.push({ abs, kind: 'file' });
+  };
+
+  for (const item of candidates) {
+    const raw = item.raw;
+    if (!path.isAbsolute(raw) && !(raw.startsWith('~/') || raw === '~')) skip.rel += 1;
+    const abs = resolveReadablePath(raw, item.cwd || cwd);
+    if (!abs) { skip.enoent += 1; continue; }
+    queue(abs);
+  }
+
+  const stats = {
+    kept: 0,
+    bytes: 0,
+    enoent: skip.enoent,
+    cap: skip.cap,
+    dir: skip.dir,
+    rel: skip.rel,
+    bash: bash.length,
+  };
+  if (!pending.length) log(fileBindLog(stats));
+  return {
+    text: '',
+    files: 0,
+    bytes: 0,
+    pending,
+    reason: pending.length ? null : 'none-kept',
+    ...stats,
+  };
+}
+
+/**
+ * Background filebind: expand directories, read bytes, log the real totals.
+ *
+ * Takes the `pending` list (or the whole collect result) from filesForCorpus.
+ * Children of a directory skip node_modules/.git/dist/build/__pycache__/.venv/target
+ * and hidden names. Same size cap as the request-path collector.
+ *
+ * Always logs `file-bind kept=N bytes=B skip enoent=X cap=Y dir=Z rel=W bash=K`
+ * so grep-for-FILES is no longer the only signal. Bytes, not 0.0MB.
+ */
+export function readFilesForCorpus(collected, {
+  boundFiles,
+  cap = Number(process.env.OPENZOO_BIND_FILE_MAX || 400_000),
+  log = () => {},
+  statSync = (p) => fs.statSync(p),
+  readFileSync = (p) => fs.readFileSync(p, 'utf8'),
+  readdirSync = (p) => fs.readdirSync(p),
+} = {}) {
+  const pending = Array.isArray(collected) ? collected : (collected?.pending || []);
+  const skip = {
+    enoent: Number(collected?.enoent) || 0,
+    cap: Number(collected?.cap) || 0,
+    dir: Number(collected?.dir) || 0,
+    rel: Number(collected?.rel) || 0,
+  };
+  const bash = Number(collected?.bash) || 0;
   const chunks = [];
-  let skippedCap = 0;
-  let skippedBound = 0;
-  let skippedMissing = 0;
-  let skippedRelative = 0;
-  for (const raw of paths) {
-    const p = resolveReadablePath(raw, cwd);
-    if (!p) { skippedRelative += 1; continue; }
-    if (seen.has(p)) continue;
-    seen.add(p);
+  const readSeen = new Set();
+
+  const readOne = (abs) => {
+    if (!abs || readSeen.has(abs)) return;
+    readSeen.add(abs);
     try {
-      const st = statSync(p);
-      if (!st.isFile()) { skippedMissing += 1; continue; }
-      if (st.size > cap) { skippedCap += 1; continue; }
-      const key = `${p}:${st.mtimeMs}`;
-      if (boundFiles?.has(key)) { skippedBound += 1; continue; }
-      boundFiles?.add(key);
-      chunks.push(`FILE ${p}\n${readFileSync(p)}`);
+      chunks.push(`FILE ${abs}\n${readFileSync(abs)}`);
     } catch {
-      skippedMissing += 1;
+      skip.enoent += 1;
     }
+  };
+
+  const bindChild = (abs) => {
+    let st;
+    try { st = statSync(abs); } catch { skip.enoent += 1; return; }
+    if (!st.isFile()) return;
+    if (st.size > cap) { skip.cap += 1; return; }
+    const key = `${abs}:${st.mtimeMs}`;
+    if (boundFiles?.has(key)) return;
+    boundFiles?.add(key);
+    readOne(abs);
+  };
+
+  for (const item of pending) {
+    const abs = typeof item === 'string' ? item : item?.abs;
+    if (!abs) continue;
+    if (item?.kind === 'dir') {
+      let kids = [];
+      try { kids = readdirSync(abs); } catch { skip.enoent += 1; continue; }
+      for (const name of kids) {
+        if (!name || name.startsWith('.') || SKIP_DIR_NAMES.has(name)) continue;
+        bindChild(path.join(abs, name));
+      }
+      continue;
+    }
+    readOne(abs);
   }
-  if (!chunks.length) {
-    const why = skippedBound && !skippedMissing && !skippedCap
-      ? 'already bound'
-      : skippedCap && !skippedMissing
-        ? `over OPENZOO_BIND_FILE_MAX (${cap})`
-        : skippedMissing
-          ? 'unreadable or not a file'
-          : 'paths did not resolve';
-    log(`file-bind 0 because ${why}`);
-    return { text: '', files: 0, bytes: 0, reason: why };
-  }
+
   const text = chunks.join('\n\n');
-  log(`file-bind ${chunks.length} files / ${text.length} bytes`);
-  return { text, files: chunks.length, bytes: text.length, reason: null };
+  const stats = {
+    kept: chunks.length,
+    bytes: text.length,
+    enoent: skip.enoent,
+    cap: skip.cap,
+    dir: skip.dir,
+    rel: skip.rel,
+    bash,
+  };
+  log(fileBindLog(stats));
+  return { text, files: chunks.length, bytes: text.length, reason: chunks.length ? null : 'none-kept', ...stats };
+}
+
+/**
+ * path:mtime keys -> absolute paths. mtime is always the last `:Number` segment
+ * so `C:\foo:1734.2` still splits correctly.
+ */
+export function boundAbsFromKeys(boundFiles) {
+  const out = new Set();
+  if (!boundFiles) return out;
+  for (const key of boundFiles) {
+    if (typeof key !== 'string' || !key) continue;
+    const i = key.lastIndexOf(':');
+    if (i <= 0) { out.add(key); continue; }
+    const rest = key.slice(i + 1);
+    if (rest !== '' && Number.isFinite(Number(rest))) out.add(key.slice(0, i));
+    else out.add(key);
+  }
+  return out;
+}
+
+const FILE_VIEW = /^(head|tail|cat|less|more|type|Get-Content|gc)\b/i;
+
+/** `head -80 notes.md` and `cd dir && cat x` count; `npm test` and `cat x | rg y` do not. */
+export function looksLikeFileView(command) {
+  if (typeof command !== 'string' || !command.trim()) return false;
+  let sawView = false;
+  for (const part of command.split(/(?:&&|\|\||;|\n)/)) {
+    const t = part.trim();
+    if (!t) continue;
+    if (/^cd\s+/.test(t)) continue;
+    if (/\|/.test(t)) return false;
+    if (FILE_VIEW.test(t)) { sawView = true; continue; }
+    return false;
+  }
+  return sawView;
+}
+
+export function fileBoundStub(paths) {
+  const list = [...new Set((paths || []).filter(Boolean))].join(' ');
+  return list ? `FILE ${list} [bound]` : 'FILE [bound]';
+}
+
+function toolContentLength(content) {
+  if (typeof content === 'string') return content.length;
+  if (Array.isArray(content)) {
+    return content.reduce((n, b) => n + (typeof b === 'string' ? b.length : String(b?.text ?? b?.content ?? '').length), 0);
+  }
+  if (content && typeof content === 'object') return JSON.stringify(content).length;
+  return 0;
+}
+
+function resolveBoundPath(raw, cwd, boundAbs) {
+  if (!boundAbs?.size) return null;
+  const t = typeof raw === 'string' ? raw.trim() : '';
+  if (!t) return null;
+  const abs = resolveReadablePath(t, cwd);
+  if (abs && boundAbs.has(abs)) return abs;
+  if (boundAbs.has(t)) return t;
+  return null;
+}
+
+/**
+ * After a file is bound, drop its tool_result / file body from the forwarded
+ * tail. Keep the path and a short marker. The model already has the bytes in
+ * the bound corpus via recall; shipping them again makes sent ≈ corpus and
+ * the gateway's `counterfactualTokens > promptTokens` gate barely fires
+ * (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.
+ *
+ * `fromIndex` limits the rewrite to the forwarded tail so the spilled prefix
+ * that becomes the conversation corpus is unchanged.
+ */
+export function stubBoundFileResults(msgs, {
+  boundFiles,
+  boundAbs,
+  cwd = process.cwd(),
+  fromIndex = 0,
+} = {}) {
+  const absSet = boundAbs || boundAbsFromKeys(boundFiles);
+  if (!Array.isArray(msgs) || !absSet.size) {
+    return { messages: msgs, stubbed: 0, dropped: 0 };
+  }
+
+  const stubIds = 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);
+    const raws = [];
+    collectStructuredPaths(args, raws);
+    if (typeof args.command === 'string' && looksLikeFileView(args.command)) {
+      for (const p of extractBashPaths(args.command, currentCwd).paths) raws.push(p.raw);
+    }
+    const resolved = [];
+    for (const raw of raws) {
+      const hit = resolveBoundPath(raw, currentCwd, absSet);
+      if (hit) resolved.push(hit);
+    }
+    if (!resolved.length || !id) return;
+    stubIds.add(id);
+    idPaths.set(id, [...(idPaths.get(id) || []), ...resolved]);
+  };
+
+  for (const m of msgs) {
+    if (!m || typeof m !== 'object') continue;
+    if (m.role === 'tool' && typeof m.content === 'string') {
+      const hint = parseCwdHint(m.content);
+      if (hint) currentCwd = hint;
+    }
+    const calls = [
+      ...(Array.isArray(m.tool_calls) ? m.tool_calls : []),
+      ...(m.function_call ? [m.function_call] : []),
+    ];
+    for (const c of calls) noteCall(c);
+    const blocks = Array.isArray(m.content) ? m.content : [];
+    for (const b of blocks) {
+      if (b?.type === 'tool_use') {
+        noteCall({ id: b.id, arguments: b.input, function: { name: b.name, arguments: b.input } });
+      }
+    }
+  }
+
+  if (!stubIds.size) return { messages: msgs, stubbed: 0, dropped: 0 };
+
+  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)) {
+      const n = toolContentLength(m.content);
+      if (!n) return m;
+      dropped += n;
+      stubbed += 1;
+      return { ...m, content: fileBoundStub(idPaths.get(m.tool_call_id)) };
+    }
+    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;
+      const n = toolContentLength(b.content);
+      if (!n) return b;
+      dropped += n;
+      stubbed += 1;
+      changed = true;
+      return { ...b, content: fileBoundStub(idPaths.get(b.tool_use_id)) };
+    });
+    return changed ? { ...m, content: blocks } : m;
+  });
+  return { messages, stubbed, dropped };
 }
 
 /** Session counters the HUD reads off /v1/info. */
@@ -309,11 +631,13 @@ export function createSpillStats() {
       this.fileBindBytes += bytes;
       this.spilledChars += bytes;
     },
-    snapshot() {
+    snapshot({ boundChars = null } = {}) {
+      const unique = boundChars == null ? this.spilledChars : boundChars;
       return {
         calls: this.spillCalls,
         chars: this.spilledChars,
-        tokensApprox: Math.round(this.spilledChars / 4),
+        // Unique bound size — do not re-add the same prefix on every reuse.
+        tokensApprox: Math.round(unique / 4),
         reusedBinds: this.spillReuses,
         fileBinds: this.fileBinds,
         fileBindBytes: this.fileBindBytes,

package/package.json

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