openzoo 0.48.70 → 0.48.71

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,7 @@ 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, createSpillStats, corpusCharsForSend,
 } from './spill.js';
 import { maybeRewriteModel, rewritablePath, augmentModelList, ALIAS_IDS } from './models.js';
 import { forgetContext } from './contexts.js';
@@ -395,7 +395,7 @@ async function spillTranscript(body, log, req, stats) {
     void bindCorpus(files, {
       appendTo,
       onStage: (stage, info) => {
-        if (stage === 'binding') log(`binding ${mb(info.bytes)}MB of FILES (${label})`);
+        if (stage === 'binding') log(`binding ${info.bytes} bytes (${mb(info.bytes)}MB) of FILES (${label})`);
       },
     }).then((b) => {
       if (!b?.contextId) return;
@@ -721,7 +721,7 @@ async function spillTranscript(body, log, req, stats) {
     void bindCorpus(files, {
       appendTo: bind.contextId,
       onStage: (stage, info) => {
-        if (stage === 'binding') log(`appending ${mb(info.bytes)}MB of FILES to ${bind.contextId} (background)`);
+        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}`));
   }
@@ -776,6 +776,8 @@ async function spillTranscript(body, log, req, stats) {
     corpus,
     reused: bind.reused,
     savedBytes: bind.bytes,
+    sent,
+    msgs: msgs.length,
   };
 }
 
@@ -837,6 +839,8 @@ async function maybeCacheCorpus(req, bodyBuf, log, stats) {
     corpus,
     reused: bind.reused,
     savedBytes: bind.bytes,
+    sent: 1,
+    msgs: msgs.length,
   };
 }
 
@@ -900,6 +904,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 +1049,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 +1510,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 +1520,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,140 @@ 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}`;
+}
+
 /**
  * Read every new file the agent touched and return the corpus slice to bind.
  *
- * Read-only, size-capped, path+mtime deduped. Failures never throw — this
- * runs on the request path.
+ * Live path is OpenAI tool_calls (Read/Edit/Write + Bash command). Relative
+ * paths resolve against cwd / last "current working directory is …" hint.
+ * Directories expand to children that are files under the cap.
  *
- * Always reports `file-bind N files / X bytes` or `file-bind 0 because …`
- * so a silent empty extract cannot hide again.
+ * 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 filesForCorpus(msgs, {
   boundFiles,
@@ -239,53 +291,72 @@ export function filesForCorpus(msgs, {
   log = () => {},
   statSync = (p) => fs.statSync(p),
   readFileSync = (p) => fs.readFileSync(p, 'utf8'),
+  readdirSync = (p) => fs.readdirSync(p),
 } = {}) {
+  const empty = { kept: 0, bytes: 0, enoent: 0, cap: 0, dir: 0, rel: 0, bash: 0 };
   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' };
+    log(fileBindLog(empty));
+    return { text: '', files: 0, bytes: 0, reason: 'disabled', ...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 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 tryBind = (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;
+      let kids = [];
+      try { kids = readdirSync(abs); } catch { skip.enoent += 1; return; }
+      for (const name of kids) {
+        if (!name || name.startsWith('.') || SKIP_DIR_NAMES.has(name)) continue;
+        const kid = path.join(abs, name);
+        let ks;
+        try { ks = statSync(kid); } catch { skip.enoent += 1; continue; }
+        if (ks.isFile()) tryBind(kid);
+      }
+      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);
     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;
     }
+  };
+
+  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; }
+    tryBind(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: bash.length,
+  };
+  log(fileBindLog(stats));
+  return { text, files: chunks.length, bytes: text.length, reason: chunks.length ? null : 'none-kept', ...stats };
 }
 
 /** Session counters the HUD reads off /v1/info. */
@@ -309,11 +380,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.71",
   "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",