openzoo 0.50.74 → 0.50.76

package/lib/bindpath.js

@@ -22,6 +22,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { config } from './config.js';
+import { createHash } from 'node:crypto';
 import { corpusHash, rememberContext, lookupContext } from './contexts.js';
 import { withNamespace } from './namespace.js';
 
@@ -122,6 +123,74 @@ export function splitIntoParts(text, maxBytes = MAX_PART_BYTES) {
   return parts;
 }
 
+
+/**
+ * DELTA BIND — ship only the chunks the server does not already hold.
+ *
+ * The whole-bind path below hashes the CONCATENATED corpus and re-uploads
+ * every part on a miss, so editing one file in a repo re-ships the tree.
+ * MEASURED here: a 23MB Rust tree in 4MB parts ran 25s -> 30s -> 65s, and a
+ * deploy mid-bind threw five good parts away.
+ *
+ * Here the unit is one file (split further only when a file alone exceeds a
+ * part). Probe with sha256 per chunk, get back {missing, known}, ship the
+ * missing in batches under MAX_PART_BYTES, and when every hash resolves the
+ * corpus binds under an ordinary context_id — through the same chunked path
+ * as a whole bind, so recall cannot tell the difference. MEASURED on the
+ * sidecar: 6 files / 124,350 chars, editing one file re-ships 22,525 (18%).
+ *
+ * Any non-200 anywhere returns null and the caller falls back to the whole
+ * bind. Delta is an optimisation; it must never be the reason a bind fails.
+ */
+const sha256 = (t) => createHash('sha256').update(t, 'utf8').digest('hex');
+
+async function postDelta(payload) {
+  const r = await fetch(`${config.apiBase}/v1/hrr/delta`, {
+    method: 'POST',
+    headers: withNamespace({ 'content-type': 'application/json' }),
+    body: JSON.stringify(payload),
+  });
+  if (r.status !== 200) return null;
+  const j = await r.json().catch(() => null);
+  return j && Array.isArray(j.missing) ? j : null;
+}
+
+async function bindDelta(fileTexts, shardKey, onProgress) {
+  const chunks = [];
+  for (const t of fileTexts) for (const part of splitIntoParts(t)) chunks.push(part);
+  const hashes = chunks.map(sha256);
+  const byHash = new Map(hashes.map((h, i) => [h, chunks[i]]));
+
+  const probe = await postDelta({ chunk_hashes: hashes, shard_key: shardKey });
+  if (!probe) return null;
+  let missing = probe.missing;
+  const total = chunks.reduce((n, c) => n + Buffer.byteLength(c), 0);
+  onProgress?.({ stage: 'delta', chunks: chunks.length, missing: missing.length, bytes: total });
+
+  let last = probe;
+  let shipped = 0;
+  while (missing.length) {
+    // one fill per batch under the part ceiling; the last fill assembles
+    const batch = {};
+    let size = 0;
+    for (const h of missing) {
+      const t = byHash.get(h);
+      if (t === undefined) return null;
+      if (size && size + Buffer.byteLength(t) > MAX_PART_BYTES) break;
+      batch[h] = t; size += Buffer.byteLength(t);
+    }
+    if (!Object.keys(batch).length) return null;
+    last = await postDelta({ chunk_hashes: hashes, chunks: batch, shard_key: shardKey });
+    if (!last) return null;
+    shipped += size;
+    onProgress?.({ stage: 'delta-fill', shipped, of: total, remaining: last.missing.length });
+    if (last.missing.length >= missing.length) return null;   // no progress: refused chunks
+    missing = last.missing;
+  }
+  if (!last.complete || !last.context_id) return null;
+  return { contextId: last.context_id, chunks: chunks.length, shipped, bytes: total };
+}
+
 async function postBind(payload) {
   const r = await fetch(`${config.apiBase}/v1/hrr/bind`, {
     method: 'POST',
@@ -167,9 +236,9 @@ export async function bindPath(target, { exts, onProgress, force = false } = {})
   // Each file is prefixed with its path so retrieval can cite where a passage
   // came from — a corpus of concatenated files with no provenance is much
   // less useful to answer from. HTML is reduced to its text (see readAsText).
-  const text = files
-    .map((f) => `===== ${path.relative(path.dirname(resolved), f) || path.basename(f)} =====\n${readAsText(f)}`)
-    .join('\n\n');
+  const fileTexts = files
+    .map((f) => `===== ${path.relative(path.dirname(resolved), f) || path.basename(f)} =====\n${readAsText(f)}`);
+  const text = fileTexts.join('\n\n');
 
   const bytes = Buffer.byteLength(text);
   const hash = corpusHash(text);
@@ -181,6 +250,18 @@ export async function bindPath(target, { exts, onProgress, force = false } = {})
     }
   }
 
+  // Delta first: on a re-bind after an edit this ships one file, not the tree.
+  // OPENZOO_BIND_DELTA=0 forces the whole-bind path.
+  if (process.env.OPENZOO_BIND_DELTA !== '0') {
+    try {
+      const d = await bindDelta(fileTexts, resolved, onProgress);
+      if (d) {
+        rememberContext(config.apiBase, hash, d.contextId);
+        return { contextId: d.contextId, files, parts: d.chunks, bytes, reused: false, delta: true, shipped: d.shipped };
+      }
+    } catch { /* fall through to the whole bind */ }
+  }
+
   const parts = splitIntoParts(text);
   onProgress?.({ stage: 'start', files: files.length, parts: parts.length, bytes });
 

package/lib/botlog.js

@@ -9,6 +9,9 @@
  * Default is QUIET: only milestones and problems. `--verbose` / OPENZOO_DEBUG=1
  * restores the firehose (it is still the right thing for debugging the wire).
  */
+import fsSync from 'node:fs';
+import osMod from 'node:os';
+import pathMod from 'node:path';
 import { privateKeyToAccount } from 'viem/accounts';
 
 const NOISE = [
@@ -30,6 +33,8 @@ const NOISE = [
 ];
 
 const MILESTONE = [
+  /zoo POST :8402 model=/,           // one line per turn: which bot asked which model
+  /<< zoo (200|4\d\d|5\d\d)/,      // one line per turn: how it ended
   /mcp ready/,
   /mcp \S+ (mode=|FAIL|tools=\d+|re-attach|attached|appeared)/,
   /mcp \S+ To let bots drive your real Chrome/,
@@ -49,11 +54,29 @@ export function isBotMilestone(line) {
   return MILESTONE.some((re) => re.test(s));
 }
 
-export function makeBotLogger({ verbose = false, write = (m) => console.error(m) } = {}) {
+/**
+ * Terminal gets milestones (or everything with verbose); the FULL stream is
+ * always appended to `file` so quiet mode never destroys evidence.
+ * Default file: ~/.openzoo/bot.log (truncated at start of each run).
+ */
+export function makeBotLogger({ verbose = false, write = (m) => console.error(m), file = defaultBotLogPath(), fsMod = null } = {}) {
+  let fd = null;
+  if (file) {
+    try {
+      const fsx = fsMod || fsSync;
+      fsx.mkdirSync(pathMod.dirname(file), { recursive: true });
+      fd = fsx.openSync(file, 'w');
+      fsx.writeSync(fd, `# openzoo bot full log ${new Date().toISOString()}\n`);
+    } catch { fd = null; }
+  }
   return (m) => {
+    if (fd != null) { try { (fsMod || fsSync).writeSync(fd, `${new Date().toISOString()} ${m}\n`); } catch { /* disk full etc. */ } }
     if (verbose || isBotMilestone(m)) write(`  backend: ${m}`);
   };
 }
+export function defaultBotLogPath(home = osMod.homedir()) {
+  return pathMod.join(home, '.openzoo', 'bot.log');
+}
 
 /**
  * The block a new user needs before anything else. `balances` is optional
@@ -86,7 +109,7 @@ export function payBannerLines({ solana, evm, balances = null, whop = 'https://w
     lines.push(`openzoo: CHROME  attached to your real browser (${chromeMode}).`);
   }
   lines.push('openzoo: FIRST   type in any bot: "set up Grok Ship for ~/path/to/repo"  — or just give it work.');
-  lines.push('openzoo: QUIET   add --verbose to see every request the app makes.');
+  lines.push('openzoo: QUIET   add --verbose to see every request the app makes; the full stream is always in ~/.openzoo/bot.log');
   return lines;
 }
 

package/lib/cursorbackend.js

@@ -1872,9 +1872,15 @@ const MODEL_ALIASES = {
   flash: 'zai-org/glm-5.3-flash',
   // NEVER OPENROUTER for Grok Bot: `auto` is the gateway router over
   // OpenRouter's catalog, so it lands on the door-only id instead.
-  auto: 'grok-4.6',
-  'openrouter/auto': 'grok-4.6',
-  'openzoo/auto': 'grok-4.6',
+  // openzoo/auto is the gateway router; the gateway keeps Auto on door-served
+  // models only, so it never lands on OpenRouter.
+  auto: 'openzoo/auto',
+  'openrouter/auto': 'openzoo/auto',
+  'openzoo/auto': 'openzoo/auto',
+  'fable-5.1': 'anthropic/claude-fable-5.1',
+  'claude-fable-5.1': 'anthropic/claude-fable-5.1',
+  'anthropic/fable-5.1': 'anthropic/claude-fable-5.1',
+  'anthropic/fable-5': 'anthropic/claude-fable-5',
   deepseek: 'deepseek/deepseek-v4-pro',
   'deepseek-pro': 'deepseek/deepseek-v4-pro',
   'deepseek-flash': 'deepseek/deepseek-v4-flash',
@@ -1888,7 +1894,7 @@ const MODEL_ALIASES = {
  *  — the bazaar (x402 upstream) row, not OpenRouter's `x-ai/grok-4.6`. The
  *  gateway serves the bare id off an x402 door with an on-chain cogs receipt,
  *  so an OpenRouter credit outage cannot take it down. */
-export const DEFAULT_ZOO_MODEL = 'grok-4.6';
+export const DEFAULT_ZOO_MODEL = 'openzoo/auto';
 async function resolveModelId(raw) {
   const s = String(raw || '').trim();
   if (!s) return null;

package/package.json

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