openzoo 0.49.18 → 0.50.0

package/lib/proxy.js

@@ -1,7 +1,6 @@
 import { readFileSync, appendFileSync, mkdirSync } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import fs from 'node:fs';
 import http from 'node:http';
 import crypto from 'node:crypto';
 import { Readable } from 'node:stream';
@@ -11,32 +10,27 @@ import {
 import { PayClient, QuoteTooHighError, UnderfundedError } from './pay.js';
 import { tokenBalance } from './x402.js';
 import { evmTokenBalance } from './evm.js';
-import { bindCorpus, contextCacheDisabled, BIND_MIN_CHARS } from './hrr.js';
-import {
-  loadBoundChars, noteCorpusLedger, filesForCorpus, readFilesForCorpus, boundAbsFromKeys,
-  createSpillStats, corpusCharsForSend, msgText, hudDollarX,
-  spillPricedLine,
-  planConversationBind, rememberSpillMemo, SPILL_CONTENT_ANCHOR_CHARS,
-  corpusRecall,
-  decideChatSpill, isOneShotCorpusAsk,
-} from './spill.js';
-import { rewritablePath, modelsListForRequest, isHarnessAliasId, rewriteChatModel, zooModelIds, CLASSIFY_MAX_TOKENS, raiseReasoningMaxTokens, isAutoModel } from './models.js';
-import {
-  route as routeTask, routeChatBody, fallbackChain, isRetryableStatus,
-  outcomeFromResponse, recordRouteOutcome, autoModelListEntry,
-} from './modelroute.js';
-import { forgetContext } from './contexts.js';
-import { injectBrief } from './brief.js';
+import { modelsListForRequest, isHarnessAliasId } from './models.js';
 import { withNamespace } from './namespace.js';
-import { anthropicToOpenAI, openAIToAnthropic, streamOpenAIToAnthropic, writeAnthropicSse } from './anthropic.js';
-import { responsesToChat, chatToResponses, writeResponsesSse } from './responses.js';
-import { streamOpenAIToResponses } from './responses-stream.js';
 import { loadSessionSpend, saveSessionSpend } from './session.js';
 import { creditBalance, quotedPrices } from './info.js';
 import { priceHoldings } from './livestatus.js';
 import { receiptUsedCogs, receiptDirectUsd, pairActualBilled } from './racesettle.js';
 import { fetchHeaders } from './fetch.js';
 
+// THE SHIM IS A FACILITATOR, NOT A MIDDLEBOX.
+//
+// Everything that used to rewrite the request on the way through — model-id
+// rewriting, the tiny-classify pin, the reasoning max_tokens floor, transcript
+// spilling / corpus binding, brief injection, system-message hoisting,
+// Anthropic /v1/messages and Responses translation, AUTO routing — now lives
+// on the backend. This proxy does exactly three jobs:
+//   1. x402: answer the gateway's 402 with a signed payment (PayClient),
+//   2. tunnel: publish + gate the public URL,
+//   3. meter: read receipts so the operator can see spend vs direct.
+// The request body is forwarded byte-for-byte. If a body looks wrong upstream,
+// the fix belongs on the backend, never here.
+
 const HOP_BY_HOP = new Set([
   'host', 'connection', 'keep-alive', 'transfer-encoding', 'upgrade',
   'proxy-authorization', 'proxy-connection', 'te', 'trailer', 'content-length',
@@ -54,14 +48,12 @@ const HOP_BY_HOP = new Set([
  * Be forgiving about the path, the same way we are about model ids.
  * Harnesses are configured with a base_url that ALREADY ends in /v1, so an
  * agent building "{base}/v1/hrr/bind" sends /v1/v1/hrr/bind and gets a 404 it
- * cannot diagnose (observed: agent concluded the bind endpoint "is not
- * functioning as advertised" and fell back to stuffing the corpus inline).
- * Collapse repeated /v1 and add a missing one.
+ * cannot diagnose. Collapse repeated /v1 and add a missing one.
  */
 function normalizePath(url) {
   const [path, query] = (url || '/').split(/(?=\?)/);
   let p = path.replace(/^(?:\/v1)+(?=\/v1\/)/, '');       // /v1/v1/x -> /v1/x
-  if (!/^\/v1(\/|$)/.test(p) && /^\/(hrr|chat|models|completions|embeddings|usage|responses)/.test(p)) p = `/v1${p}`;
+  if (!/^\/v1(\/|$)/.test(p) && /^\/(hrr|chat|models|completions|embeddings|usage|responses|messages)/.test(p)) p = `/v1${p}`;
   return p === path ? url : `${p}${query || ''}`;
 }
 
@@ -70,12 +62,8 @@ function upstreamHeaders(req) {
   for (const [k, v] of Object.entries(req.headers)) {
     if (!HOP_BY_HOP.has(k.toLowerCase())) out[k] = v;
   }
-  // EVERY forwarded request carries this wallet's context namespace, not just
-  // the ones PayClient builds itself. Without it a bind sent THROUGH the proxy
-  // (an agent posting to /v1/hrr/bind) landed in the shared tenant while the
-  // chat that referenced it looked in the wallet's tenant — the context was
-  // unreachable and every spill bind came back 400, silently forwarding the
-  // whole body at full price.
+  // EVERY forwarded request carries this wallet's context namespace — binds
+  // and the chats that reference them must land in the same tenant.
   return withNamespace(out);
 }
 
@@ -130,66 +118,6 @@ function jsonErr(res, status, message, extraFields = {}) {
   res.end(JSON.stringify({ error: { message }, ...extraFields }));
 }
 
-const mb = (n) => (n / 1048576).toFixed(1);
-
-// anchor -> { corpus, contextId, hash } for append-only transcript spills
-const spillMemo = new Map();
-// path:mtime of every file already bound — a file is bound once per version,
-// never re-uploaded because the agent read it again.
-const boundFiles = new Set();
-// context_id -> total chars BOUND (turns + files appended). The counterfactual
-// basis must reflect what the corpus actually holds, not just this turn's slice.
-const boundChars = new Map();
-// sessionKey -> { contextId, chars } so a sidecar restart can keep appending
-// to the same context and still send the accumulated x-hrr-corpus-chars.
-const sessionLedger = new Map();
-loadBoundChars(boundChars, { sessions: sessionLedger, boundFiles });
-
-// THIS MAP SURVIVES A RESTART, OR THE COUNTERFACTUAL DOES NOT.
-//
-// boundChars is the only record of how large a bound corpus has GROWN. It feeds
-// `x-hrr-corpus-chars`, which is what lets the gateway price the counterfactual
-// against the whole corpus instead of against the turn in front of it. Held
-// purely in memory, every restart silently reset that basis to the live body and
-// savings fell to exactly 1.00x until a session re-accumulated — with nothing in
-// the log to say why, because the corpus in the DAEMON was still there. Only our
-// accounting of it was gone.
-//
-// MEASURED minutes after a restart: `basis 16112 tok vs sent 16112 -> 4238 ·
-// billed 1.14063 direct 1.14063`. The body spilled 3.8x and the bill did not
-// move, because basis fell back to `cached.corpus?.length`.
-//
-// Advisory, never load-bearing: a corrupt or missing file just means we start
-// counting again, which is exactly today's behaviour.
-const BOUND_CHARS_FILE = path.join(os.homedir(), '.openzoo', 'bound-chars.json');
-const BOUND_CHARS_MAX = 500; // newest contexts only; this is a ledger, not a log
-
-let boundCharsRestored = 0;
-try {
-  const saved = JSON.parse(fs.readFileSync(BOUND_CHARS_FILE, 'utf8'));
-  for (const [ctx, chars] of Object.entries(saved)) {
-    if (typeof chars === 'number' && chars > 0) boundChars.set(ctx, chars);
-  }
-  boundCharsRestored = boundChars.size;
-} catch { /* absent or unreadable — start empty, same as before */ }
-
-let boundCharsTimer = null;
-/** Debounced: appends land in bursts, and the basis only has to survive a
- *  restart, not every keystroke. Never rejects — persistence is a nicety. */
-const persistBoundChars = () => {
-  if (boundCharsTimer) return;
-  boundCharsTimer = setTimeout(() => {
-    boundCharsTimer = null;
-    try {
-      // Map preserves insertion order, so the tail is the newest.
-      const entries = [...boundChars.entries()].slice(-BOUND_CHARS_MAX);
-      mkdirSync(path.dirname(BOUND_CHARS_FILE), { recursive: true });
-      fs.writeFileSync(BOUND_CHARS_FILE, JSON.stringify(Object.fromEntries(entries)));
-    } catch { /* advisory */ }
-  }, 2000);
-  boundCharsTimer.unref?.(); // must never hold the process open
-};
-
 /**
  * Every fundable balance across all three chains, for the startup line and
  * the live refresh. Each read is independent and advisory — one lagging RPC
@@ -227,22 +155,19 @@ function balanceLine(snap) {
 }
 
 /**
- * The zoo answers chat completions as ONE JSON object (it settles payment
- * before serving — there is nothing to stream until generation is done).
- * Harnesses that sent `stream: true` expect SSE and treat a JSON body as a
- * dead connection: Cursor shows "Reconnecting…", RETRIES, and every retry is
- * a fresh payment. So the proxy honours the contract itself — the finished
- * completion is re-emitted as spec-shaped chat.completion.chunk events.
+ * When the zoo answers a chat completion as ONE JSON object but the harness
+ * sent `stream: true`, honour the streaming contract ourselves — a JSON body
+ * on an expected SSE socket reads as a dead connection (Cursor shows
+ * "Reconnecting…", RETRIES, and every retry is a fresh payment). An upstream
+ * that truly streams passes straight through relay(), untouched.
  */
 function serveAsSse(res, data, upstream) {
   const headers = {
     'content-type': 'text/event-stream; charset=utf-8',
     'cache-control': 'no-cache',
     // Tell any proxy in front of us (cloudflare quick tunnel, nginx) NOT to
-    // buffer the stream. Without this the tunnel accumulates the whole SSE
-    // body and releases it at once, which reorders/merges the tool_call frames
-    // an agent parses incrementally — observed as "provider-side tool-call
-    // protocol error" over the tunnel while localhost (no proxy) is fine.
+    // buffer the stream — buffering reorders/merges tool_call frames an agent
+    // parses incrementally.
     'x-accel-buffering': 'no',
     connection: 'keep-alive',
   };
@@ -259,9 +184,8 @@ function serveAsSse(res, data, upstream) {
       ev({ ...base, choices: [{ index: c.index ?? 0, delta: { content: c.message.content }, finish_reason: null }] });
     }
     // Agent mode lives or dies here: a finish_reason of "tool_calls" with the
-    // calls themselves dropped strands the harness mid-turn (observed: Cursor
-    // agent hangs). Streaming spec: tool_calls ride the delta with an index,
-    // arguments as a string chunk — one full chunk per call is valid SSE.
+    // calls themselves dropped strands the harness mid-turn. Streaming spec:
+    // tool_calls ride the delta with an index, arguments as a string chunk.
     if (Array.isArray(c.message?.tool_calls) && c.message.tool_calls.length) {
       ev({
         ...base,
@@ -290,24 +214,15 @@ function serveAsSse(res, data, upstream) {
  * body within seconds, and each retry used to be a fresh payment (observed:
  * six identical $0.06 settles for one Cursor message). An identical POST body
  * arriving within the window is served the cached completion, not re-paid.
- * Window is deliberately short: a genuinely new turn always differs (harnesses
- * resend the whole conversation), so only true retries can hit.
+ * Window is deliberately short: a genuinely new turn always differs.
  */
 const REPLAY_TTL_MS = 30_000;
-const replayCache = new Map(); // sha256(body) -> { at, data, settle }
+const replayCache = new Map(); // sha256(body+headers) -> { at, data, settle }
 /**
- * The key MUST include the routing headers, not just the body.
- *
- * Keying on the body alone was a correctness bug, not merely a caching one:
- * N shards asking the SAME question of N DIFFERENT bound corpora send
- * byte-identical bodies and differ only in X-HRR-Context. They collided on one
- * key, so shards 2..N were served shard 1's answer — REPRODUCED in the field:
- * 10 shards, 7 byte-identical replies across corpora known to differ, and the
- * batch finished in 12s where a single uncached call took ~7s.
- *
- * Wrong answers attributed to the wrong corpus is a far worse failure than the
- * double-billing this cache exists to prevent, so every header that can change
- * the ANSWER joins the key.
+ * The key MUST include the routing headers, not just the body: N shards asking
+ * the SAME question of N DIFFERENT bound corpora send byte-identical bodies and
+ * differ only in X-HRR-Context. Wrong answers attributed to the wrong corpus is
+ * a far worse failure than the double-billing this cache exists to prevent.
  */
 const REPLAY_KEY_HEADERS = ['x-hrr-context', 'x-hrr-top-k', 'x-hrr-gate', 'x-openzoo-namespace'];
 
@@ -333,483 +248,6 @@ function replayPut(key, data, settle) {
   }
 }
 
-/**
- * "The body never ships twice" at the proxy. A chat body whose LAST message
- * carries a huge pasted corpus gets split at its last blank line — corpus vs
- * ask — so the corpus can be bound ONCE on the zoo and every later call ships
- * only the ask plus X-HRR-Context. The split point is deterministic, which is
- * what makes the sha256 manifest hit on run 2 even when the question changed.
- *
- * Conservative on purpose: only a single big STRING content on the final
- * message, only when a blank-line boundary exists, and any failure falls back
- * to sending the original body untouched — caching must never break a call.
- * Returns null (send as-is) or { body, contextId, hash, corpus, reused, savedBytes }.
- */
-/**
- * Spill the OLD prefix of a long TRANSCRIPT into leCore.
- *
- * WHY THIS EXISTS. The only spill was the corpus+question shape below, which
- * requires the last message to be one big string ending in `\n\n<question>` —
- * true for zoo_ask, never true for an agent. `npx openzoo claude` therefore
- * spilled NOTHING, hit Claude Code's own context ceiling, and auto-compacted,
- * on a product whose pitch is that it does not have to. Compaction was honest
- * given nothing was offloaded; this is what makes the claim true.
- *
- * Runs on the OpenAI shape ON PURPOSE. /v1/messages is translated by
- * anthropicToOpenAI and rewritten to /v1/chat/completions BEFORE this is
- * reached, so operating here covers Claude Code, Cursor and the raw API with
- * one implementation instead of three that can drift.
- *
- * THE CUT POINT IS NOT NEGOTIABLE. An assistant `tool_calls` must be answered
- * by role:"tool" messages or the upstream 400s, so the transcript may only be
- * 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, extra = {}) {
-  const msgs = Array.isArray(body?.messages) ? body.messages : null;
-  if (!msgs?.length) return null;
-
-  // 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 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']
-    || req?.headers?.['x-session-id']
-    || req?.headers?.['x-claude-session-id']
-    || (typeof body?.metadata?.user_id === 'string' ? body.metadata.user_id : null);
-  let sessionKey = sessionId ? `sid:${sessionId}` : null;
-
-  const ledgerOpts = () => ({ sessionKey, sessions: sessionLedger, boundFiles });
-  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 = 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;
-      }
-      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}`));
-    });
-  };
-
-  // LIVE SELF-TUNER. Env knobs seed the first cut; after cut+stub the proxy
-  // 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.
-  //
-  // 1-model AND raced grokui AUTO both land here (same POST /chat/completions
-  // door). The old `msgs.length < 6` bail skipped fat 1-model hops � a 40k
-  // command-output turn with 4�5 messages never bound, so spent?direct.
-  // decideChatSpill is the shared gate: oversized ? bind prefix + system/tail
-  // + x-hrr-context; small ? passthrough. Race fields do not change it.
-  const knownLedger = (sessionKey && spillMemo.get(sessionKey))
-    || (sessionKey && sessionLedger.get(sessionKey))
-    || null;
-  const knownChars = knownLedger?.contextId
-    ? (boundChars.get(knownLedger.contextId) || 0)
-    : 0;
-  const decision = decideChatSpill(body, {
-    corpusChars: knownChars,
-    boundAbs: previouslyBoundAbs,
-    recall: corpusRecall(typeof knownLedger?.corpus === 'string' ? knownLedger.corpus : ''),
-    log,
-    persist: true,
-    dollarX: extra.dollarX ?? hudDollarX(stats || {}),
-    lastSend: extra.lastSend,
-    minPrefixChars: BIND_MIN_CHARS,
-  });
-  if (decision.mode === 'passthrough') {
-    bindFilesInBackground(decision.reason === 'no-cut'
-      ? 'no severable cut, files only'
-      : 'conversation under spill threshold, background');
-    return null;
-  }
-  if (decision.mode === 'stub-only') {
-    bindFilesInBackground('no severable cut, files only');
-    // Still forward stubbed/trimmed bodies so an un-severable storm is not
-    // shipped at full size just because cutTranscript could not move.
-    return {
-      body: Buffer.from(JSON.stringify({ ...body, messages: decision.forwarded })),
-      corpus: '',
-      reused: false,
-      savedBytes: 0,
-      sent: decision.forwarded.length,
-      msgs: msgs.length,
-    };
-  }
-  // oneshot is handled in maybeCacheCorpus; if we reach it here, bind the
-  // extracted corpus the same way as a transcript prefix.
-  if (decision.mode === 'oneshot' && !decision.adapted) {
-    decision.adapted = {
-      cut: msgs.length - 1,
-      firstSpillable: Math.max(0, msgs.findIndex((m) => m?.role !== 'system')),
-      stubbed: { messages: decision.forwarded, stubbed: 0, dropped: 0 },
-    };
-  }
-  const adapted = decision.adapted;
-  const { cut, firstSpillable } = adapted;
-  const stubbed = adapted.stubbed;
-
-  const head = decision.head.length ? decision.head : msgs.slice(0, firstSpillable);     // system block, always kept
-  // EVERY FILE THE AGENT TOUCHED, AT FULL SIZE.
-  //
-  // The saving ratio is corpus/sent, so on a fresh session — where the corpus
-  // IS the conversation — it starts near 1x and only climbs as you talk. That
-  // is exactly what the live agent numbers showed: 1.0-1.3x early, 8x once a
-  // 149k-token history existed. MEASURED the same day: prompt compressed 2.67x
-  // but billed savings was 1.13x, because output does not compress and a small
-  // corpus leaves nothing to compress on the other side either.
-  //
-  // Files are the fix. An agent reads far more bytes than it discusses, the
-  // harness has usually TRUNCATED them on the way in, and the full text is
-  // 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 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.
-  //
-  // The first conversation bind is also fire-and-forget: turn 1 may go out
-  // unspilled while the bind runs, then later turns recall a tail + contextId.
-  // Folding file bytes into a synchronous first bind used to put a 400KB
-  // upload in front of the caller's turn (0.34-0.48s on a 613KB corpus).
-  //
-  // Nothing recalls a file during the turn that read it � the model already has
-  // the tool result in its window. Files are only worth having bound for the
-  // NEXT ask, so they append after the conversation bind completes.
-  const turns = decision.prefix
-    || msgs.slice(firstSpillable, cut).map(msgText).filter(Boolean).join('\n\n');
-  const corpus = turns;
-  if (!sessionKey) sessionKey = corpus.slice(0, SPILL_CONTENT_ANCHOR_CHARS);
-
-  // Conversation prefix binds at any size. BIND_MIN_CHARS only gates the
-  // one-shot corpus+question path in maybeCacheCorpus � a real but small
-  // early-turn prefix used to be discarded here ("only large ones").
-  if (!corpus) {
-    bindFilesInBackground('empty conversation prefix, files only');
-    return null;
-  }
-
-  // CONTINUE THE CONTEXT, BIND ONLY THE DELTA.
-  //
-  // A transcript grows by one message per turn, so the whole-corpus hash misses
-  // every time and the old code re-uploaded the ENTIRE prefix on every single
-  // turn � OBSERVED live: 0.4MB bound three turns running, a fresh context id
-  // each time, while only a few KB was actually new. Bind cost grew with
-  // conversation length and was re-paid per message.
-  //
-  // The corpus is append-only: each turn's corpus starts with the previous
-  // one. So when it does, send just the tail and keep the same context_id.
-  // Anchored on the FIRST 2KB, which is stable for the life of a conversation
-  // and distinguishes concurrent ones.
-  // KEY ON THE SESSION, NOT ON THE CONTENT.
-  //
-  // The anchor was the first 2KB of corpus, which works only because a
-  // transcript's opening never changes. It is fragile in exactly the cases that
-  // matter: two sessions that open identically (same system block, same first
-  // instruction � the norm for an agent) collide onto ONE bound context and
-  // interleave their histories, and any edit near the top of a transcript
-  // silently orphans the binding and re-uploads the whole thing.
-  //
-  // Claude Code identifies its session, so use that when it is offered and fall
-  // back to the content anchor when it is not. Same memo, better key.
-  // CAPTURED FROM A LIVE claude-cli/2.1.232 REQUEST, not guessed. The first
-  // version of this checked x-session-id / x-claude-session-id /
-  // metadata.user_id � none of which Claude Code sends, so it silently fell
-  // back to the content anchor on every request and the feature did nothing.
-  // The real header list is:
-  //   anthropic-beta, anthropic-version, x-app, x-claude-code-session-id,
-  //   x-stainless-*
-  //
-  // COLD-BIND. Turn 1 may go unspilled (full messages, no x-hrr-context) while
-  // the first bind runs in the background � same spirit as file-bind, so the
-  // opening ask is not stalled. The in-flight/completed bind is memoized on
-  // the session key; later turns recall a tail + contextId. Subsequent
-  // appends stay fire-and-forget deltas.
-  let bindPlan = planConversationBind({
-    sessionKey,
-    corpus,
-    spillMemo,
-    sessionLedger,
-  });
-  const anchor = bindPlan.key || sessionKey;
-
-  if (bindPlan.action === 'cold-bind') {
-    const ready = bindCorpus(corpus, {
-      onStage: (stage, info) => {
-        if (stage === 'binding') log(`binding ${mb(info.bytes)}MB of transcript to holographic memory (background)...`);
-      },
-    }).then((b) => {
-      if (!b?.contextId) return b;
-      noteCorpusLedger(boundChars, {
-        contextId: b.contextId,
-        reused: false,
-        corpusChars: corpus.length,
-        deltaChars: 0,
-        fileChars: 0,
-        ...ledgerOpts(),
-      });
-      rememberSpillMemo(spillMemo, anchor, { corpus, contextId: b.contextId, hash: b.hash });
-      bindFilesInBackground('background', { appendTo: b.contextId, asAppend: true });
-      return b;
-    }).catch((e) => {
-      log(`bind failed (turn went unspilled): ${e.message}`);
-      const cur = spillMemo.get(anchor);
-      if (cur?.pending) spillMemo.delete(anchor);
-      return null;
-    });
-    rememberSpillMemo(spillMemo, anchor, { corpus, pending: true, ready });
-    return null;
-  }
-
-  if (bindPlan.action === 'await-pending') {
-    const finished = await bindPlan.ready.catch((e) => {
-      log(`bind failed (history may lag one turn): ${e.message}`);
-      return null;
-    });
-    if (!finished?.contextId) {
-      bindFilesInBackground('first bind failed, files only');
-      return null;
-    }
-    bindPlan = planConversationBind({
-      sessionKey: anchor,
-      corpus,
-      spillMemo,
-      sessionLedger,
-    });
-  }
-
-  if (bindPlan.action !== 'recall' || !bindPlan.contextId) {
-    bindFilesInBackground('no context yet, files only');
-    return null;
-  }
-
-  let bind;
-  let deltaChars = 0;
-  let appended = false;
-  if (bindPlan.restored && bindPlan.contextId) {
-    // Sidecar came back up: we still know the context_id and the accumulated
-    // char count, but not the prior prefix string, so we cannot slice a delta.
-    // Re-append the current prefix (some overlap is harmless) and keep the
-    // restored ledger � do not add corpus.length again.
-    void bindCorpus(corpus, {
-      appendTo: bindPlan.contextId,
-      onStage: (stage, info) => {
-        if (stage === 'binding') log(`appending ${mb(info.bytes)}MB to ${bindPlan.contextId} (restored session, background)`);
-      },
-    }).catch((e) => log(`append failed (history may lag one turn): ${e.message}`));
-    appended = true;
-    bind = { contextId: bindPlan.contextId, hash: bindPlan.hash, reused: true, bytes: 0 };
-  } else if (bindPlan.append && bindPlan.delta) {
-    const delta = bindPlan.delta;
-    deltaChars = delta.length;
-    // FIRE AND FORGET. This delta is history for FUTURE turns � the answer
-    // being generated right now is served from the tail plus what is already
-    // bound, so waiting on the upload buys nothing and costs the user the
-    // round trip on every single turn. The context id is already known, so
-    // nothing is lost by not waiting for it.
-    void bindCorpus(delta, {
-      appendTo: bindPlan.contextId,
-      onStage: (stage, info) => {
-        if (stage === 'binding') log(`appending ${mb(info.bytes)}MB to ${bindPlan.contextId} (delta, background)`);
-      },
-    }).catch((e) => log(`append failed (history may lag one turn): ${e.message}`));
-    appended = true;
-    bind = { contextId: bindPlan.contextId, hash: bindPlan.hash, reused: true, bytes: delta.length };
-  } else {
-    bind = { contextId: bindPlan.contextId, hash: bindPlan.hash, reused: true, bytes: 0 };
-  }
-  // CONVERSATION LEDGER � every successful bind AND append, not only when
-  // files exist. First bind initializes to the bound corpus size; each append
-  // adds the delta; file bytes ride on top. This is what makes x-hrr-corpus-chars
-  // the accumulated bound corpus instead of this-turn's prefix.
-  noteCorpusLedger(boundChars, {
-    contextId: bind.contextId,
-    reused: appended,
-    corpusChars: corpus.length,
-    deltaChars,
-    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.
-  // Read + readdir are inside setImmediate � they must not run before send().
-  bindFilesInBackground('background', { appendTo: bind.contextId, asAppend: true });
-  rememberSpillMemo(spillMemo, anchor, { corpus, contextId: bind.contextId, hash: bind.hash });
-  // 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';
-  // WHAT ACTUALLY REACHES THE MODEL. Inference about this cut has been wrong
-  // twice; the roles of the forwarded tail settle it in one line.
-  if (process.env.OPENZOO_LOG_TAIL === '1') {
-    const roles = msgs.slice(cut).map((m) => (m.role || '?')[0]).join('');
-    const lastU = msgs.slice(cut).some((m) => m.role === 'user' && msgText(m).trim());
-    log(`  tail roles=${roles} firstSpillable=${firstSpillable} cut=${cut} hasUserText=${lastU}`);
-  }
-  log(bind.reused
-    ? `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`);
-
-  // 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}`);
-  }
-
-  // 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,
-  // same corpus, nearly double the saving. Recall breadth, not markup, is the
-  // lever, and spilling 34k tokens only to recall 22k of them back is not a
-  // saving, it is a round trip.
-  //
-  // So budget the recall in TOKENS and derive k from it, rather than fixing the
-  // chunk count and letting the token cost fall where it may. ~320 tokens per
-  // chunk measured. The budget scales with the ask — a one-line question needs
-  // far less context than a detailed one — and is clamped so a huge ask cannot
-  // drag the whole corpus back in.
-  const askChars = msgText(msgs[msgs.length - 1] || {}).length;
-  // BREADTH IS THE LEVER, AND MORE OF IT IS WORSE. MEASURED on a 56,265-token
-  // corpus: top_k 32 handed back 9,990 tokens and scored 2.45x, top_k 8 handed
-  // back 2,574 and scored 4.73x — same question, same answer, nearly double the
-  // saving. Spilling 34k tokens to recall 22k of them back is a round trip, not
-  // a saving. So budget the recall tighter and cap k where the measurement says
-  // the value is, rather than at the largest number that still fits.
-  const budget = Math.min(
-    Number(process.env.OPENZOO_RECALL_MAX_TOKENS || 3000),
-    Math.max(Number(process.env.OPENZOO_RECALL_MIN_TOKENS || 1200),
-             Math.round(askChars / 3)),
-  );
-  const topK = Math.max(4, Math.min(12, Math.round(budget / 320)));
-
-  return {
-    body: Buffer.from(JSON.stringify({
-      ...body,
-      messages: decision.forwarded || [...head, ...stubbed.messages.slice(cut)],
-    })),
-    topK,
-    contextId: bind.contextId,
-    hash: bind.hash,
-    corpus,
-    reused: bind.reused,
-    savedBytes: bind.bytes,
-    sent,
-    msgs: msgs.length,
-  };
-}
-
-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
-  if (bodyBuf.length <= BIND_MIN_CHARS) {
-    // Still walk the transcript: a short agent turn that Read a file should
-    // bind it even when there is nothing large enough to spill.
-    try {
-      const body = JSON.parse(bodyBuf.toString('utf8'));
-      if (Array.isArray(body?.messages) && body.messages.length) {
-        return spillTranscript(body, log, req, stats, extra);
-      }
-    } catch { /* not json */ }
-    return null;
-  }
-  let body;
-  try { body = JSON.parse(bodyBuf.toString('utf8')); } catch { return null; }
-  const msgs = Array.isArray(body?.messages) ? body.messages : null;
-  if (!msgs?.length) return null;
-  // CORPUS+QUESTION first — one huge final message ending in \n\n<ask>. That is
-  // what zoo_ask and the chat surface send, and binding exactly that body keeps
-  // the ask verbatim. Anything else (an agent transcript) falls through to the
-  // transcript spill, which used to be a silent no-op.
-  const last = msgs[msgs.length - 1];
-  // Same gate decideChatSpill uses � 1-model and race share it. zoo_ask
-  // stays on the corpus+question bind; everything else (including grokui
-  // AUTO, raced or not) falls through to spillTranscript ? decideChatSpill.
-  if (!isOneShotCorpusAsk(msgs, BIND_MIN_CHARS)) 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, extra);
-
-  const bind = await bindCorpus(corpus, {
-    onStage: (stage, info) => {
-      if (stage === 'binding') log(`binding ${mb(info.bytes)}MB corpus to holographic memory (one-time)...`);
-    },
-  });
-  noteCorpusLedger(boundChars, {
-    contextId: bind.contextId,
-    reused: false,
-    corpusChars: corpus.length,
-    sessions: sessionLedger,
-    boundFiles,
-  });
-  if (bind.reused) {
-    log(`corpus already bound (${bind.hash.slice(0, 12)}… → ${bind.contextId}) — skipped ${mb(bind.bytes)}MB upload`);
-  } else {
-    log(`corpus bound once (${mb(bind.bytes)}MB → ${bind.contextId}) — repeats of this body are near-free`);
-  }
-  const rewritten = { ...body, messages: [...msgs.slice(0, -1), { ...last, content: ask }] };
-  return {
-    body: Buffer.from(JSON.stringify(rewritten)),
-    contextId: bind.contextId,
-    hash: bind.hash,
-    corpus,
-    reused: bind.reused,
-    savedBytes: bind.bytes,
-    sent: 1,
-    msgs: msgs.length,
-  };
-}
-
 /**
  * `requireToken` / `sessionMaxUsd` are TUNNEL MODE (see lib/tunnel.js): once the
  * proxy is reachable from the internet, the api key stops being decorative and
@@ -819,16 +257,10 @@ async function maybeCacheCorpus(req, bodyBuf, log, stats, extra = {}) {
 export async function startProxy({ silent = false, requireToken = null, sessionMaxUsd = null, autoTunnel = false } = {}) {
   const client = new PayClient();
   const log = silent ? () => {} : (...a) => console.log(...a);
-  // ALWAYS-ON. `silent: true` is used by the editor path to keep startup tidy,
-  // but it also swallowed the per-request lines and the payment receipts — so the
-  // terminal sat blank and there was no way to tell a working setup from an editor
-  // quietly answering from its own backend. Traffic and receipts are the whole
-  // point of watching this window; they are never silenced.
   // ALWAYS-ON, BUT NEVER INTO A HARNESS'S TERMINAL. `silent` means another
   // process (openzoo claude, the editor launcher) owns stdio — printing request
-  // lines / payment receipts there corrupts that program's output (observed: the
-  // Solana receipt leaking into the Claude Code CLI). When silent, route this
-  // channel to a log file instead; only print to the console when we own it.
+  // lines / payment receipts there corrupts that program's output. When silent,
+  // route this channel to a log file instead; only print when we own the console.
   const restored = loadSessionSpend();
   let paidCalls = restored.paidCalls;
   let sayFile = null;
@@ -838,9 +270,6 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       mkdirSync(path.dirname(sayFile), { recursive: true });
     } catch { sayFile = null; }
   }
-  // Spill/adapt/classifier lines must use this channel: `log` is a no-op when
-  // `openzoo claude` starts us with silent:true, and printing them on stdout
-  // corrupts the Claude Code TTY. say() writes ~/.openzoo/proxy.log then.
   const say = (...a) => {
     const line = a.join(' ');
     if (sayFile) { try { appendFileSync(sayFile, line + '\n'); return; } catch { /* fall through */ } }
@@ -854,7 +283,7 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
     saveSessionSpend({ spentUsd: sessionSpent, cogsUsd: sessionCogs, directUsd: sessionDirect, paidCalls });
   };
   if (restored.ok && (sessionSpent > 0 || paidCalls > 0)) {
-    say(`session restored: $${sessionSpent.toFixed(6)} � ${paidCalls} paid call${paidCalls === 1 ? '' : 's'}`);
+    say(`session restored: $${sessionSpent.toFixed(6)} · ${paidCalls} paid call${paidCalls === 1 ? '' : 's'}`);
   }
   process.on('exit', rememberSpend);
   const noteQuote = (x) => {
@@ -880,44 +309,18 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
   // where public traffic slips through ungated.
   let tunnelGate = null;
   // How many chat requests actually ARRIVED. The single number that answers
-  // "is the editor really routing through us?" — an editor that silently keeps
-  // using its own backend leaves this at 0 while looking perfectly healthy.
+  // "is the editor really routing through us?"
   let servedRequests = 0;
-  // SPILL ACCOUNTING. The product's whole claim is that context is offloaded
-  // 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
-  // degrading when it is just the mix changing. OBSERVED: 1.3166 -> 1.1823
-  // while spilled calls and offloaded tokens both sat completely still.
-  // spillSpend / spillDirect live on `spill` (createSpillStats).
   // ACTUAL UPSTREAM SPEND, FROM THE PROVIDER — not our estimate of it.
-  //
-  // Every other dollar figure here is derived from OpenRouter's CATALOG price
-  // times a token count we guessed, and the guess is bad in a specific
-  // direction: output is priced on `max_tokens`, which callers set as a ceiling.
-  // MEASURED 2026-08-19: a call we quoted at $0.9858 (32,000 reserved output
-  // tokens) actually cost $0.007962 — OpenRouter's own number, 124x smaller.
-  //
-  // OpenRouter returns `usage.cost` on every completion, so the real figure is
-  // already in the response body and needs no extra request and no account-level
-  // lookup. That last part matters: /api/v1/credits reports the WHOLE key's
-  // lifetime usage, and this key also pays for ttfx direct runs and other work,
-  // so the account total can never attribute a dollar to this proxy. Per-call
-  // cost can.
+  // OpenRouter returns `usage.cost` on every completion; per-call cost is the
+  // only figure attributable to THIS proxy.
   let sessionActual = 0;
   let actualCalls = 0;
   // billed for ONLY those calls whose real cost we learned — the honest
-  // numerator for markupX. See the comment at the usage.cost site.
+  // numerator for markupX.
   let billedWithActual = 0;
-  // CREDIT, CACHED. Users cannot tell prepaid credit from wallet balance and
-  // have to guess whether a call was even paid for ("I don't think x402 made me
-  // pay this at all"). The status line runs EVERY turn, so this is refreshed at
-  // most every 20s and served stale in between — a status line must never add
-  // latency to the thing it is describing.
+  // CREDIT, CACHED. Refreshed at most every 20s and served stale in between —
+  // a status line must never add latency to the thing it is describing.
   let creditUsd = null;
   let creditAt = 0;
   let creditInflight = null;
@@ -949,23 +352,14 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
 
   const server = http.createServer(async (req, res) => {
     // MCP on the SAME port as the proxy. One `npx openzoo` gives a harness
-    // both surfaces: point base_url at /v1 for transparent context spilling,
-    // or add /mcp for tools (zoo_bind, zoo_ask...). Running two commands to
-    // get both was friction nobody should pay.
-    // This wallet's own running total for THIS proxy process — every paid
-    // call through this port counts (GUI, MCP, CLI, any harness), not just
-    // whichever surface happens to be asking. Local-only, no auth needed:
-    // it's a number, not a capability.
+    // both surfaces: point base_url at /v1, or add /mcp for tools.
     if (req.method === 'GET' && (req.url || '').split('?')[0] === '/v1/session') {
-      // NEVER await fly.dev. Serve last-known; a hung keep-alive on the same
-      // undici pool as brainRace used to wedge this handler (LISTEN up, HTTP 000).
-      // refreshCredit() is fire-and-forget so HUD "continue" cannot sit on HTTP 000.
+      // NEVER await fly.dev. Serve last-known; refreshCredit() is
+      // fire-and-forget so HUD "continue" cannot sit on HTTP 000.
       refreshCredit().catch(() => {});
       refreshPrices();
       const money = walletMoney();
       res.writeHead(200, { 'content-type': 'application/json' });
-      // Same package.json the startup banner reads � grokui-app refuses to
-      // attach to a leftover :8402 whose version is older than it shipped with.
       const { version } = JSON.parse(
         readFileSync(new URL('../package.json', import.meta.url), 'utf8'),
       );
@@ -977,9 +371,8 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       return;
     }
 
-    // Public addresses only — never the private key. Exists so a caller (the
-    // grokui error path, in particular) can print REAL funding instructions
-    // inline instead of telling the user to go look somewhere else.
+    // Public addresses only — never the private key. Exists so a caller can
+    // print REAL funding instructions inline.
     if (req.method === 'GET' && (req.url || '').split('?')[0] === '/v1/wallet') {
       refreshCredit().catch(() => {});
       refreshPrices();
@@ -989,8 +382,6 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         solana: client.address,
         evm: client.evmAddress,
         funding: fundingLine(client.address),
-        // from the same background poll the startup/refresh lines use, so a
-        // caller can tell a genuinely empty wallet from a transient 402
         balances: balanceLine(lastSnap || []) || null,
         funded: (lastSnap || []).some((b) => b.ui > 0),
         creditUsd,
@@ -1010,10 +401,8 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       return;
     }
 
-    // THE CUTESY GUI. Local browsers hitting GET / get a little chat app —
-    // model zoo, bind-a-corpus drawer, live spent/saved ticker off the x402
-    // receipts. Tunnel traffic (cf headers) keeps the JSON discovery below:
-    // the GUI is the operator's, not the public's.
+    // THE CUTESY GUI. Local browsers hitting GET / get a little chat app.
+    // Tunnel traffic (cf headers) keeps the JSON discovery below.
     {
       const p0 = (req.url || '').split('?')[0];
       const local = !(req.headers['cf-connecting-ip'] || req.headers['cf-ray']);
@@ -1032,7 +421,7 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       log(`path ${req.url} -> ${normalized} (base_url already ends in /v1)`);
       req.url = normalized;
     }
-    let url = `${config.apiBase}${req.url}`;
+    const url = `${config.apiBase}${req.url}`;
     // Requests that arrived over the public quick-tunnel URL carry cloudflared's
     // headers; nothing dialing 127.0.0.1 directly does. That distinction is what
     // lets localhost stay keyless while the SAME port is safely public.
@@ -1051,11 +440,8 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         return;
       }
     }
-    // ROUTING TRUTH, SERVED FROM WHATEVER URL YOU REACHED US ON. A cloud agent
-    // only ever touches the tunnel, so asking a local MCP process "what is my
-    // routing" is the wrong question — the answer has to come from the tunnel
-    // itself, and name the tunnel. Free and unauthenticated: discovery must
-    // never be the thing that is gated.
+    // ROUTING TRUTH, SERVED FROM WHATEVER URL YOU REACHED US ON. Free and
+    // unauthenticated: discovery must never be the thing that is gated.
     {
       const p0 = (req.url || '').split('?')[0];
       if (req.method === 'GET' && (p0 === '/v1/info' || p0 === '/info')) {
@@ -1070,30 +456,16 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
           reachedVia: viaTunnel ? 'public tunnel' : 'localhost',
           publicTunnel: tunnelGate?.publicUrl ? `${tunnelGate.publicUrl}/v1` : null,
           servedRequests,
-          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
-          // bill; spend beside the counterfactual is the product. The receipt
-          // already carries directUsd per call — it simply never reached the
-          // status line, so the one number that justifies the tool was the one
-          // the user could not see.
+          // bill; spend beside the counterfactual is the product.
           directUsd: sessionDirect,
           savedUsd: Math.max(0, sessionDirect - sessionSpent),
           savingX: sessionSpent > 0 ? Number((sessionDirect / sessionSpent).toFixed(4)) : null,
           paidCalls,
-          // WHAT THE INFERENCE ACTUALLY COST, as reported by OpenRouter on each
-          // completion (`usage.cost`). Every other figure above is a catalog
-          // estimate built on `max_tokens`; this is metered. `margin` is the
-          // honest gross on this session — the number that says whether the
-          // pricing is sane, which no estimate can.
+          // WHAT THE INFERENCE ACTUALLY COST, as reported by the provider on
+          // each completion (`usage.cost`). `margin` is the honest gross.
           actual: {
             calls: actualCalls,
             upstreamUsd: Number(sessionActual.toFixed(6)),
@@ -1107,12 +479,7 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
           auth: viaTunnel
             ? 'this public URL requires the oz_… bearer for paid endpoints; /v1/models and /v1/hrr/bind are free'
             : 'localhost is keyless',
-          context: {
-            yourAttentionWindow: 'unchanged — openzoo does not enlarge it',
-            boundCeiling: '~128M tokens client-usable via bind + retrieval',
-            singleRequestLimit: '~8MB per request; larger corpora bind in parts',
-            retrieval: 'lossy top-k retrieval, NOT lossless compression',
-          },
+          shim: 'pure passthrough — request bodies are forwarded byte-for-byte; all message/model handling is on the backend',
           tools: ['zoo_bind', 'zoo_ask', 'zoo_status', 'zoo_models', 'zoo_wallet', 'zoo_contexts'],
           docs: 'https://openzoo.fun',
         }, null, 2));
@@ -1123,18 +490,9 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
     if (viaTunnel) {
       const got = (req.headers.authorization || '').replace(/^Bearer\s+/i, '').trim();
       // TRUST ON FIRST USE, so a stale key still works without weakening the
-      // tunnel to "any key forever".
-      //
-      // Tunnel tokens are minted per session, so a client holding a key from an
-      // earlier run silently failed — and the only fixes were re-pasting by
-      // hand or writing into the editor's OS-encrypted credential store, which
-      // would mean prompting for keychain access to install a value the user
-      // never chose. Instead: the printed token always works, and the FIRST
-      // other key to present itself claims the tunnel for the rest of the
-      // session. Your editor (which reaches the URL first, from this machine)
-      // adopts it; anyone who finds the URL afterwards is refused because the
-      // slot is taken. The URL is unguessable and ephemeral, the spend ceiling
-      // still applies, and OPENZOO_TUNNEL_STRICT=1 restores exact-match only.
+      // tunnel to "any key forever". The printed token always works, and the
+      // FIRST other key to present itself claims the tunnel for the session.
+      // OPENZOO_TUNNEL_STRICT=1 restores exact-match only.
       const strict = process.env.OPENZOO_TUNNEL_STRICT === '1';
       let authed = got === tunnelGate.token;
       if (!authed && !strict && got.length >= 8) {
@@ -1147,11 +505,8 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         }
       }
       const p = (req.url || '').split('?')[0];
-      // DISCOVERY IS FREE. An agent probing this URL cold should be able to
-      // work out what it is and what to ask its operator for — a bare 401 on
-      // every path just sends it spelunking through the operator's machine.
-      // Reads that cost nothing and leak nothing (the catalog is public on
-      // the zoo anyway) go through without the key; money paths stay gated.
+      // DISCOVERY IS FREE. Reads that cost nothing and leak nothing go through
+      // without the key; money paths stay gated.
       if (!authed) {
         if (req.method === 'GET' && (p === '/' || p === '/v1' || p === '/v1/info')) {
           res.writeHead(200, { 'content-type': 'application/json' });
@@ -1162,18 +517,15 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
             endpoints: {
               'GET /v1/models': 'model catalog with pricing + context_length — no key needed',
               'GET /v1/models/{id}': 'single-model probe — no key needed',
-              'POST /v1/chat/completions': 'chat (streaming supported, any model id — unknown ids are matched to the nearest served model) — key required',
+              'POST /v1/chat/completions': 'chat (streaming supported) — key required',
             },
             docs: 'https://openzoo.fun · https://www.npmjs.com/package/openzoo',
           }, null, 2));
           return;
         }
-        // Binding COSTS NOTHING — no 402, no wallet, no settlement. Gating it
-        // behind the key only stopped agents from using the one endpoint that
-        // makes a big corpus workable: observed in the wild, an agent wrote a
-        // correct multi-part bind script, got 401 on the final append, and
-        // fell back to stuffing the corpus inline. The money paths below stay
-        // gated; the worst a stranger can do here is spend our sidecar's disk.
+        // Binding COSTS NOTHING — no 402, no wallet, no settlement. The money
+        // paths below stay gated; the worst a stranger can do here is spend
+        // the sidecar's disk.
         const freeRead = req.method === 'GET' && (p === '/v1/models' || p.startsWith('/v1/models/'));
         const freeBind = req.method === 'POST' && p === '/v1/hrr/bind';
         if (freeBind) log(`public url: unauthenticated bind allowed (free endpoint) from ${req.socket.remoteAddress}`);
@@ -1196,348 +548,28 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       return;
     }
 
-    // Local decision � no upstream, no payment. Same keys as Python route().
-    {
-      const routePath = (req.url || '').split('?')[0];
-      if (req.method === 'POST' && (routePath === '/route' || routePath === '/v1/route')) {
-        let payload;
-        try { payload = JSON.parse(bodyBuf.toString('utf8') || '{}'); } catch {
-          jsonErr(res, 400, 'invalid /route body');
-          return;
-        }
-        try {
-          const r = routeTask(payload.text ?? '', {
-            allow_free: payload.allow_free ?? false,
-            bindable: payload.bindable ?? true,
-            context: payload.context,
-            input_tokens: payload.input_tokens,
-            has_image: payload.has_image,
-            needs_tools: payload.needs_tools,
-            needs_json: payload.needs_json,
-            ...(payload.constraints && typeof payload.constraints === 'object' ? payload.constraints : {}),
-          });
-          res.writeHead(200, { 'content-type': 'application/json' });
-          res.end(JSON.stringify(r));
-        } catch (err) {
-          jsonErr(res, 500, `openzoo /route: ${err.message}`);
-        }
-        return;
-      }
-    }
-
-    // ANTHROPIC MESSAGES SHAPE. A harness pointed here via ANTHROPIC_BASE_URL
-    // (Claude Code, the Anthropic SDKs) speaks POST /v1/messages, not chat
-    // completions — this is how such a harness routes its inference through
-    // x402 without any DNS or TLS trickery. Translate the body to OpenAI shape
-    // and rewrite the path so EVERYTHING downstream (model rewrite, brief,
-    // corpus cache, payment, replay, streaming) runs unchanged; translate the
-    // answer back on the way out. See lib/anthropic.js.
-    let anthropicMode = false;
-    let anthropicModel = null;
-    // The CLIENT's streaming intent, kept separate from the body we send
-    // upstream. The Anthropic lane asks the gateway for a complete message (we
-    // can only translate a finished one) while still owing the caller SSE.
-    let clientWantsStream = false;
-    let responsesMode = false;
-    let responsesModel = null;
-    let responsesCustom = null;   // names of freeform tools needing custom_tool_call on the way back
     const rawPath = (req.url || '').split('?')[0];
-
-    // RESPONSES API. Some harnesses speak only this wire format — OpenAI's
-    // Codex Security CLI pins `wire_api: "responses"` in its provider table, so
-    // a bare 404 here made it fall back to wss://api.openai.com and bypass the
-    // proxy entirely while reporting the failure as an auth error. Translate
-    // in, translate out; everything between stays on the chat path.
-    if (req.method === 'POST' && (rawPath === '/v1/responses' || rawPath === '/responses')) {
-      try {
-        const inbound = JSON.parse(bodyBuf.toString('utf8'));
-        // TEMP CAPTURE: dump the first few Responses requests so the agent's
-        // actual wire usage (store / previous_response_id / tool shapes) can be
-        // read rather than inferred. Guarded by an env var so it is off unless
-        // asked for.
-        if (process.env.OZ_CAPTURE_RESPONSES) {
-          try {
-            const fs = await import('node:fs');
-            const dir = process.env.OZ_CAPTURE_RESPONSES;
-            fs.mkdirSync(dir, { recursive: true });
-            const n = fs.readdirSync(dir).length;
-            // Capture the LATER turns too. Turn 1 is already understood; the
-            // unknown is what codex sends back after running a tool, so bias
-            // the capture toward requests that carry a tool result.
-            const hasResult = Array.isArray(inbound.input)
-              && inbound.input.some((i) => i && String(i.type || '').endsWith('_call_output'));
-            const tag = hasResult ? 'result' : 'plain';
-            if (n < 24) fs.writeFileSync(`${dir}/${tag}-${n}.json`, JSON.stringify(inbound, null, 2));
-          } catch { /* capture must never break a paid call */ }
-        }
-        responsesModel = inbound.model;
-        const meta = {};
-        const translated = responsesToChat(inbound, meta);
-        // Codex's watchdog is ~10s to first SSE byte. Force stream so we can
-        // emit response.created immediately instead of buffering Opus.
-        translated.stream = true;
-        bodyBuf = Buffer.from(JSON.stringify(translated));
-        responsesCustom = meta.custom;
-        responsesMode = true;
-        req.url = '/v1/chat/completions';
-        url = `${config.apiBase}${req.url}`;
-      } catch {
-        jsonErr(res, 400, 'invalid responses body');
-        return;
-      }
-    }
-
-    if (req.method === 'POST' && (rawPath === '/v1/messages' || rawPath === '/messages')) {
-      try {
-        const inbound = JSON.parse(bodyBuf.toString('utf8'));
-        anthropicModel = inbound.model;
-        // ANTHROPIC CLIENTS CANNOT READ AN OPENAI STREAM.
-        //
-        // The gateway now streams for real, and `relay()` pipes those frames
-        // through untouched — which is correct for an OpenAI client and
-        // unreadable to Claude Code, which speaks the Anthropic SSE grammar
-        // (message_start / content_block_delta / message_stop). It surfaced as
-        // "API returned an empty or malformed response (HTTP 200)": a 200 whose
-        // body the client cannot parse.
-        //
-        // The translation we have (openAIToAnthropic + writeAnthropicSse) works
-        // on a COMPLETE message, so this lane asks the gateway not to stream and
-        // keeps the buffered translation. That costs Claude Code the
-        // time-to-first-byte win until an incremental OpenAI->Anthropic frame
-        // translator exists; a readable answer late beats an unreadable one now.
-        const converted = anthropicToOpenAI(inbound);
-        clientWantsStream = converted.stream === true || inbound.stream === true;
-        // STREAM AGAIN. This forced `stream:false` for a few hours because
-        // relay() piped the gateway's OpenAI frames straight to a client that
-        // speaks message_start / content_block_delta, producing a 200 nobody
-        // could parse. Buffering fixed the parse and cost the whole point:
-        // Claude Code sends max_tokens=32000 against a 600-turn transcript, so
-        // every turn became minutes of zero bytes and read as a hang.
-        // streamOpenAIToAnthropic() translates the grammar frame by frame, so
-        // the lane can be fast AND readable.
-        converted.stream = clientWantsStream;
-        bodyBuf = Buffer.from(JSON.stringify(converted));
-        anthropicMode = true;
-        req.url = '/v1/chat/completions';
-        url = `${config.apiBase}${req.url}`;
-      } catch {
-        jsonErr(res, 400, 'invalid anthropic messages body');
-        return;
-      }
-    }
-
-    // Harness model ids ("gpt-5.6-sol", "claude-…") are rewritten onto the
-    // NEAREST zoo model BEFORE anything else sees the body — any POST that
-    // carries a model field, not just chat/completions, so /completions,
-    // /responses and future shapes all work. Never silent.
+    // Paid inference paths: chat completions, Anthropic messages, Responses.
+    // The BODY IS NOT TOUCHED — the parse below is read-only, to learn the
+    // client's streaming intent for the JSON→SSE compatibility path.
+    const isChat = req.method === 'POST' && rawPath.includes('/chat/completions');
+    const isPaidPost = req.method === 'POST'
+      && /\/(chat\/completions|completions|messages|responses)$/.test(rawPath);
     let wantsStream = false;
-    let autoRoute = null;
-      if ((req.url || '').includes('/chat/completions') && req.method === 'POST') {
-        servedRequests += 1;
-        say(`\n<- request #${servedRequests} from ${(req.headers['user-agent'] || 'unknown').slice(0, 40)}`);
-        // TEMPORARY: name the headers (not values) so we can see whether the
-        // client offers a session id at all. Values are never logged — several
-        // of these carry auth.
-        if (process.env.OPENZOO_LOG_HEADERS === '1') {
-          log(`  headers: ${Object.keys(req.headers).sort().join(', ')}`);
-        }
-      }
-    if (rewritablePath(req.method, req.url)) {
-      try {
-        let parsed = JSON.parse(bodyBuf.toString('utf8'));
-        wantsStream = parsed?.stream === true || clientWantsStream;
-        // TINY CLASSIFY FIRST, ON THE ORIGINAL BODY.
-        //
-        // Claude Code auto-mode sends a 16-token yes/no to claude-sonnet-5
-        // before Bash/WebSearch. Two things used to eat that call:
-        //   1. OPENZOO_DEFAULT_MODEL rewrote it onto deepseek/grok;
-        //   2. the reasoning floor then raised 16 -> 4000.
-        // Measured: 11.5s, past the caller's timeout, "claude-sonnet-5 is
-        // temporarily unavailable (timed out), so auto mode cannot determine
-        // the safety of WebSearch". Even staying on sonnet-5 is too slow
-        // (402 handshake behind a long Grok stream). Pin to a fast
-        // non-reasoning catalog id and leave max_tokens alone. Real
-        // Grok/DeepSeek chats (max_tokens 2000+ AND a long transcript)
-        // still get the 4000 floor � those still go blank without it.
-        // 0.48.75 missed grok nubs at max_tokens 128/2000 on a 1�2
-        // message body (~3� from the floor, no classifier log).
-        let ids = [];
-        try { ids = await zooModelIds(); } catch { /* catalog miss: still skip the floor on a tiny classify */ }
-        const policy = rewriteChatModel(parsed, ids, { bodyLen: bodyBuf.length });
-        parsed = policy.parsed;
-        if (!policy.tiny && (policy.auto || isAutoModel(parsed?.model))) {
-          autoRoute = routeChatBody(parsed, {
-            allow_free: false,
-            bindable: true,
-            // Live quoteable ids only � Auto must never emit :batch / $0 /
-            // missing-price rows that 500 `bad openrouter price` on Fly.
-            ...(ids.length ? { allow_ids: ids } : {}),
-          });
-          if (!autoRoute.model) {
-            jsonErr(res, 422, autoRoute.reason || 'openzoo/auto: no feasible model', { route: autoRoute });
-            return;
-          }
-          parsed = { ...parsed, model: autoRoute.model };
-          const bump = raiseReasoningMaxTokens(parsed);
-          parsed = bump.parsed;
-          say(`openzoo/auto -> ${autoRoute.model} p=${autoRoute.p_success} cleared=${autoRoute.cleared_bar} ${autoRoute.task_class}${autoRoute.bind_first ? ' bind_first' : ''}`);
-          if (!autoRoute.cleared_bar) {
-            say(`openzoo/auto cleared_bar=false � strongest fallback, not a normal pick`);
-          }
-        }
-        if (policy.tiny) {
-          // `openzoo claude` starts us silent � `log` is a no-op then. say()
-          // is the proxy.log channel and never the Claude Code TTY.
-          say(`classifier tiny max_tokens=${Number(parsed?.max_tokens)} "${policy.from}" -> ${policy.to} (no reasoning floor)`);
-        } else {
-          // SAY WHETHER THE OVERRIDE IS ACTUALLY SET, and name it.
-          //
-          // This used to print "(OPENZOO_DEFAULT_MODEL overrides)" on EVERY
-          // rewrite whether or not the variable existed � a hint about a knob,
-          // phrased as a statement about this request. It cost a real incident:
-          // the proxy was restarted from a shell carrying
-          // OPENZOO_DEFAULT_MODEL=deepseek/deepseek-v4-pro-0813, so every
-          // claude-sonnet-5 ask was served by deepseek, and the log line looked
-          // exactly the same as it always had. deepseek matches the reasoning
-          // regex, so a 16-token safety classification became a 4,000-token
-          // reasoning generation � 11.5s, past the caller's timeout, and Claude
-          // Code reported "claude-sonnet-5 is temporarily unavailable".
-          // Tiny classify is pinned above and never reaches this path.
-          if (policy.to && policy.to !== policy.from) {
-            const forced = process.env.OPENZOO_DEFAULT_MODEL;
-            log(forced
-              ? `model "${policy.from}" -> FORCED to ${forced} by OPENZOO_DEFAULT_MODEL (nearest match would have been ${policy.to})`
-              : `model "${policy.from}" is not on the zoo � nearest match ${policy.to}`);
-          }
-          // REASONING MODELS SPEND max_tokens ON THINKING FIRST.
-          //
-          // The budget covers hidden reasoning AND the visible answer, so a
-          // caller that asks for 40 tokens because it wants a short answer often
-          // gets ZERO � the whole allowance went to reasoning and the completion
-          // truncated to an empty string. Measured across three families in one
-          // day: deepseek returned 0 chars at 8k and was fine at 24k; grok-4.6
-          // pinned ct at exactly its 16,000 budget with no visible output;
-          // sonnet-5 truncated a 600-token file mid-function because Anthropic's
-          // max_tokens covers thinking too.
-          //
-          // An empty completion is not an error � it bills normally and renders
-          // as a blank reply � so this fails silently and looks like the retrieval
-          // broke. It cost real debugging time tonight for exactly that reason.
-          // Multiply the allowance for known reasoning families and let callers
-          // keep asking for what they actually want back.
-          //
-          // A MULTIPLIER ALONE IS NOT ENOUGH. 4x on a caller's 40 is 160, which is
-          // still nothing for a model that thinks first � measured, 2 of 3 runs
-          // still returned empty at 160. Reasoning needs an absolute floor, not a
-          // relative bump, so take whichever is larger.
-          if (policy.raised) {
-            log(`reasoning model ${parsed.model}: max_tokens ${policy.raisedFrom} -> ${policy.raisedTo} (thinking shares the budget; OPENZOO_REASONING_MAX_TOKENS_X=1 disables)`);
-          }
-        }
-        if (policy.tiny || policy.raised || autoRoute || (policy.to && policy.to !== policy.from)) {
-          bodyBuf = Buffer.from(JSON.stringify(parsed));
-        }
-        // Tell the agent what it is actually connected to — in band, where it
-        // will read it, instead of leaving it to guess (and to chunk corpora
-        // it could bind whole). See lib/brief.js.
-        if ((req.url || '').includes('/chat/completions')) {
-          // Tell it the URL it actually reached us on — the public tunnel for
-          // a remote harness, localhost for a local one. An agent that has to
-          // guess its own endpoint guesses a website.
-          const selfUrl = viaTunnel && tunnelGate?.publicUrl
-            ? `${tunnelGate.publicUrl}/v1`
-            : `http://localhost:${config.port}/v1`;
-          // NOT ON A YES/NO. The brief is ~2.2KB describing corpus binding,
-          // request-size limits and payment — none of which a tiny call can
-          // use. Claude Code's auto-mode safety classifier asks a 16-token
-          // question before it will run Bash, and it has a short timeout:
-          // MEASURED, that call takes 3.5s cold through here against a 0.09s
-          // gateway 402, and it times out on a machine paying on-chain. Adding
-          // 2.2KB of prose to a body that small is latency and tokens spent on
-          // advice nobody will read.
-          //
-          // Threshold is the same one the spill uses: below it there is no
-          // corpus and nothing the brief could help with. policy.tiny is
-          // that check on the ORIGINAL body, before the reasoning floor.
-          const tiny = policy.tiny
-            || (bodyBuf.length < BIND_MIN_CHARS
-              && Number(parsed?.max_tokens ?? 0) > 0
-              && Number(parsed?.max_tokens) <= CLASSIFY_MAX_TOKENS);
-          const briefed = tiny ? null : injectBrief(parsed, selfUrl);
-          if (briefed) parsed = briefed;
-          // SYSTEM MESSAGES BELONG AT THE FRONT, OR GOOGLE 400s.
-          //
-          // Claude Code emits <system-reminder> blocks mid-conversation, which
-          // is legal for Anthropic natively. Several upstreams behind OpenRouter
-          // are not: fable-5 is served by GOOGLE, whose API takes a system
-          // instruction only before the conversation starts and rejects one
-          // after. CAPTURED live — provider_error code 400,
-          // roles="sssusatatus", 311KB body: two system messages sitting after
-          // user turns, on a model that answers a simple call fine.
-          //
-          // So fold every later system message into the leading block, in
-          // order. The content survives and its position moves; the alternative
-          // is a 400 that ends the turn and tells the caller nothing.
-          const nm = Array.isArray(parsed?.messages) ? parsed.messages : null;
-          if (nm && nm.length > 1) {
-            let lead = 0;
-            while (lead < nm.length && nm[lead]?.role === 'system') lead += 1;
-            const strays = [];
-            const kept = [];
-            nm.forEach((m, i) => {
-              if (i >= lead && m?.role === 'system') strays.push(m);
-              else kept.push(m);
-            });
-            if (strays.length) {
-              const merged = strays.map((m) => (typeof m.content === 'string' ? m.content : msgText(m))).filter(Boolean).join('\n\n');
-              const head = kept.slice(0, lead);
-              const tailMsgs = kept.slice(lead);
-              if (head.length) head[head.length - 1] = { ...head[head.length - 1], content: `${typeof head[head.length - 1].content === 'string' ? head[head.length - 1].content : msgText(head[head.length - 1])}\n\n${merged}` };
-              else head.push({ role: 'system', content: merged });
-              parsed = { ...parsed, messages: [...head, ...tailMsgs] };
-              log(`hoisted ${strays.length} interleaved system message(s) to the leading block (some providers 400 otherwise)`);
-            }
-          }
-          bodyBuf = Buffer.from(JSON.stringify(parsed));
-        }
-      } catch { /* not JSON */ }
+    if (isPaidPost) {
+      servedRequests += 1;
+      say(`\n<- request #${servedRequests} from ${(req.headers['user-agent'] || 'unknown').slice(0, 40)}`);
+      try { wantsStream = JSON.parse(bodyBuf.toString('utf8'))?.stream === true; } catch { /* not JSON */ }
     }
 
     // Retry of a body we answered seconds ago? Serve the cached completion —
-    // never pay twice for a harness's reconnect loop.
-    const isChat = req.method === 'POST' && (req.url || '').includes('/chat/completions');
-    // GROUND TRUTH ON THE OUTGOING BODY. Three sessions have now reported "no
-    // actual question or task from you" while the proxy log showed a healthy
-    // forward, and two rounds of reasoning about the cut were wrong. Log what
-    // is actually in messages[] on the way out — roles, and the tail of the
-    // last user turn — so the question stops being a matter of opinion.
-    if (process.env.OPENZOO_LOG_BODY === '1' && isChat) {
-      try {
-        const b = JSON.parse(bodyBuf.toString('utf8'));
-        const ms = Array.isArray(b?.messages) ? b.messages : [];
-        const roles = ms.map((m) => (m.role || '?')[0]).join('');
-        const lastUser = [...ms].reverse().find((m) => m.role === 'user');
-        const txt = lastUser ? String(msgText(lastUser)).slice(-160).replace(/\s+/g, ' ') : '(NO USER MESSAGE)';
-        log(`  OUT roles=${roles} n=${ms.length} lastUser="${txt}"`);
-      } catch { /* not json */ }
-    }
+    // never pay twice for a harness's reconnect loop. Chat-completions JSON
+    // only: it is the one shape we know how to re-emit (including as SSE).
     const rKey = isChat ? replayKey(bodyBuf, req.headers) : null;
     if (rKey) {
       const hit = replayGet(rKey);
       if (hit) {
         log('identical request within 30s — served the cached completion, NOT re-paid');
-        // The cache stores the CHAT shape. A Responses caller must get its own
-        // wire format back, or the replay path silently answers in a format the
-        // client cannot parse — a bug that only appears on the SECOND identical
-        // request, which is exactly when nobody is watching.
-        if (responsesMode) {
-          if (wantsStream) { writeResponsesSse(res, hit.data, responsesModel, null, responsesCustom); return; }
-          const rh = { 'content-type': 'application/json' };
-          if (hit.settle) rh['x-payment-response'] = hit.settle;
-          res.writeHead(200, rh);
-          res.end(JSON.stringify(chatToResponses(hit.data, responsesModel, responsesCustom)));
-          return;
-        }
         if (wantsStream) { serveAsSse(res, hit.data, null); return; }
         const h = { 'content-type': 'application/json' };
         if (hit.settle) h['x-payment-response'] = hit.settle;
@@ -1551,8 +583,7 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
 
     // Harnesses validate their configured model BEFORE ever POSTing — some
     // list /v1/models, some probe /v1/models/<id>. Both must succeed for the
-    // ids we know how to rewrite, or the harness refuses upfront and the
-    // rewrite never gets its chance.
+    // alias ids the launchers write into configs.
     const path = (req.url || '').split('?')[0];
     if (req.method === 'GET' && path === '/v1/models') {
       // Catalog is chrome, not a paid call. Paying the list would put a 402
@@ -1561,25 +592,18 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         const response = await fetchHeaders(url, init);
         if (response.ok) {
           const payload = await response.json();
-          // Quoteable catalog only. Raw OpenRouter dump includes :batch,
-          // $0 / missing prices, and we used to mint openzoo-* twins of each
-          // � Claude Code /model then showed 63 clones and Auto 500'd.
+          // Quoteable catalog only: no :batch twins, no $0 rows, no clones.
           res.writeHead(200, { 'content-type': 'application/json' });
           res.end(JSON.stringify(modelsListForRequest(payload, req.headers)));
           return;
         }
         await response.text().catch(() => {});
-      } catch { /* gateway 402/down � serve aliases so chrome still paints */ }
+      } catch { /* gateway 402/down — serve aliases so chrome still paints */ }
       res.writeHead(200, { 'content-type': 'application/json' });
       res.end(JSON.stringify(modelsListForRequest({ object: 'list', data: [] }, req.headers)));
       return;
     }
     const probe = req.method === 'GET' && /^\/v1\/models\/(.+)$/.exec(path);
-    if (probe && isAutoModel(decodeURIComponent(probe[1]))) {
-      res.writeHead(200, { 'content-type': 'application/json' });
-      res.end(JSON.stringify(autoModelListEntry()));
-      return;
-    }
     if (probe && isHarnessAliasId(decodeURIComponent(probe[1]))) {
       res.writeHead(200, { 'content-type': 'application/json' });
       res.end(JSON.stringify({ id: decodeURIComponent(probe[1]), object: 'model', owned_by: 'openzoo-alias' }));
@@ -1587,127 +611,24 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
     }
 
     try {
-      let cached = null;
-      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, {
-          lastSend: lastSpillSend?.sent,
-          dollarX: hudDollarX({
-            spillDirect: spill.spillDirect,
-            spillSpend: spill.spillSpend,
-            sessionDirect,
-            sessionSpent,
-          }),
-        });
-      } catch (err) {
-        log(`context cache skipped for this call: ${err.message}`);
-      }
-      const send = (buf, ctxId, topK, corpusChars) => client.fetch(url, {
-        ...init,
-        body: buf,
-        headers: ctxId
-          ? {
-            ...init.headers,
-            'x-hrr-context': ctxId,
-            // Only on the spill path — a caller that set its own top-k keeps it.
-            ...(topK ? { 'x-hrr-top-k': String(topK) } : {}),
-            // TELL THE GATEWAY HOW BIG THE CORPUS IS. It has been guessing:
-            // `contextChars` is populated only when a bind passes through the
-            // gateway itself, so on an APPEND — and on every corpus that
-            // includes files the agent read, which never appear in a request
-            // body at all — it has no idea and falls back to the body size.
-            // That is why the counterfactual logged `corpus ?` all day and why
-            // a call whose corpus held 40,777 tokens priced as if it held
-            // 4,303. The proxy assembled the corpus; it is the only party that
-            // knows.
-            ...(corpusChars ? { 'x-hrr-corpus-chars': String(corpusChars) } : {}),
-          }
-          : init.headers,
-      });
-      let didSpill = false;
-      let result;
-      if (cached) {
-        spill.noteSpill({ corpusChars: cached.corpus?.length || 0, reused: cached.reused });
-        didSpill = true;
-        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) {
-          const text = await result.response.text();
-          if (/context_not_found/.test(text)) {
-            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, corpusCharsForSend(boundChars, rebound.contextId, cached.corpus?.length));
-          } else {
-            res.writeHead(404, { 'content-type': 'application/json' });
-            res.end(text);
-            return;
-          }
-        }
-      } else {
-        result = await client.fetch(url, init);
-      }
-      // Walk the auto shortlist on 429/5xx � cheapest-first among models that
-      // cleared the bar. Finite: one pass over fallbackChain(), never a loop.
-      if (autoRoute?.cleared_bar && isRetryableStatus(result.response.status)) {
-        const chain = fallbackChain(autoRoute);
-        for (const next of chain) {
-          const failed = result.response.status;
-          try { await result.response.arrayBuffer(); } catch { /* drain */ }
-          say(`openzoo/auto fallback HTTP ${failed} -> ${next}`);
-          const rewriteModel = (buf) => {
-            try {
-              const b = JSON.parse(buf.toString('utf8'));
-              b.model = next;
-              return Buffer.from(JSON.stringify(b));
-            } catch { return buf; }
-          };
-          bodyBuf = rewriteModel(bodyBuf);
-          init.body = bodyBuf;
-          if (cached) {
-            cached = { ...cached, body: rewriteModel(cached.body) };
-            result = await send(cached.body, cached.contextId, cached.topK, corpusCharsForSend(boundChars, cached.contextId, cached.corpus?.length));
-          } else {
-            result = await client.fetch(url, { ...init, body: bodyBuf });
-          }
-          if (!isRetryableStatus(result.response.status)) break;
-        }
-      }
+      const result = await client.fetch(url, init);
       const { response, paid, receipt } = result;
       if (paid && receipt) {
         if (receipt.ok && typeof receipt.billedUsd === 'number') {
           sessionSpent += receipt.billedUsd;
-          // Wallet path: no 3x. Prefer extra.cogsUsd / billedUsd / directUsd /
-          // savedUsd from the 402. billedUsd is the OpenRouter price (plus
-          // zoo's 33% of savings when the caller beat direct).
           sessionCogs += receiptUsedCogs(receipt);
           noteQuote(receipt);
-          // direct = what answering this WITHOUT the zoo would have cost. On an
-          // attach call that is the whole bound corpus, which is why it can be
-          // orders of magnitude above what was billed. Read extra.directUsd /
-          // extra.savedUsd; do not invent billed * 3.
-          if (didSpill) {
-            spill.spillSpend += receipt.billedUsd || 0;
-            spill.spillDirect += receiptDirectUsd(receipt);
-          }
           sessionDirect += receiptDirectUsd(receipt);
           // The public-URL ceiling meters only public-origin spend — your own
           // local calls never eat into it.
           if (viaTunnel) tunnelSpent += receipt.billedUsd;
         }
         const line = receipt.ok ? receipt.line : `paid retry -> HTTP ${receipt.status}`;
-        // Wherever a running total is the thing to watch, it rides the receipt.
         if (requireToken) say(`${line}  ·  session $${sessionSpent.toFixed(6)}`);
         else if (viaTunnel) say(`${line}  ·  public-url session $${tunnelSpent.toFixed(6)}`);
         else say(line);
-        // ALWAYS-ON SPEND, TUI-SAFE. When a harness owns the terminal (silent),
-        // the receipt lines go to a file (they corrupt a TUI). But the running
-        // total should still be visible — so write it to the terminal TITLE via
-        // an OSC escape, which updates the window/tab title without touching the
-        // TUI's content. `openzoo ◝ $0.0042 · 12 calls` in the title bar, live.
+        // ALWAYS-ON SPEND, TUI-SAFE: running total in the terminal TITLE via
+        // an OSC escape, never in a TUI's content.
         if (receipt.ok && typeof receipt.billedUsd === 'number') { paidCalls += 1; }
         if (receipt.ok && typeof receipt.billedUsd === 'number') rememberSpend();
         if (sayFile) {
@@ -1715,39 +636,15 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         }
         scheduleRefresh(4000); // settlement lands on-chain in a few seconds
       }
-      // Chat completions come back as one JSON object (settle-before-serve).
-      // Cache it against retries, and if the harness asked to stream, honour
-      // that contract ourselves. An upstream that someday truly streams (SSE
-      // content-type) passes straight through the relay below, untouched.
       const upCt = response.headers.get('content-type') || '';
-      const noteAutoOutcome = (status, data, streamed = false) => {
-        if (!autoRoute) return;
-        let ok = outcomeFromResponse(status, data);
-        if (ok == null) return;
-        if (streamed && status >= 200 && status < 300) ok = true;
-        recordRouteOutcome(autoRoute, ok);
-      };
-      if (isChat && response.ok && upCt.includes('application/json')) {
+      if (isPaidPost && response.ok && upCt.includes('application/json')) {
         let data = null;
         try { data = await response.clone().json(); } catch { /* not JSON after all */ }
-        // WHAT IT REALLY COST, straight from the provider. This rides every
-        // completion already — no extra call, and unlike the account-level
-        // /api/v1/credits total it is attributable to THIS proxy even though the
-        // same OpenRouter key also pays for ttfx and everything else.
+        // WHAT IT REALLY COST, straight from the provider — rides every
+        // completion already; no extra call.
         {
-          // PAIR THE NUMERATOR WITH THE DENOMINATOR. sessionSpent is summed on
-          // three paths and sessionActual on two, so markupX divided ALL billed
-          // by the SUBSET that reported a real cost � a 402-receipt call added
-          // to billed and nothing to real, and the ratio read 12.55x on a stack
-          // running at ~1.0x. Track the billed side of exactly the calls whose
-          // cost we actually learned.
-          // Both figures ride the SAME response object, so read them together
-          // rather than carrying one across sites and hoping the order holds.
-          //
-          // x402.billedUsd is often the QUOTE reserve (max_tokens � catalog),
-          // not the settled charge. MEASURED: $0.9858 reserved vs $0.007962
-          // usage.cost -> markupX lied at 124x on a ~1x call. Pair usage.cost
-          // with post-completion billed, never the reserve.
+          // PAIR THE NUMERATOR WITH THE DENOMINATOR: usage.cost with the
+          // post-completion billed twin, never the quote reserve.
           const pair = pairActualBilled(data?.x402, data?.usage);
           if (pair) {
             sessionActual += pair.upstreamUsd;
@@ -1755,64 +652,22 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
             billedWithActual += pair.billedUsd;
           }
         }
-        // PREPAID CALLS STILL COST MONEY. The block above only meters calls
-        // where THIS proxy answered a 402 and paid. When prepaid credit covers
-        // the quote the gateway serves 200 on the FIRST request, so there is
-        // no 402, no payment and no receipt — and the session read $0.05 / 2
-        // calls while the credit balance had actually fallen $3.017 -> $1.395
-        // over a 30-question run. The receipt still rides the response body,
-        // so meter it from there.
+        // PREPAID CALLS STILL COST MONEY. When prepaid credit covers the quote
+        // the gateway serves 200 on the FIRST request — no 402, no payment, no
+        // receipt. The receipt still rides the response body, so meter it there.
         if (!paid && data?.x402 && typeof data.x402.billedUsd === 'number') {
           const x = data.x402;
           sessionSpent += x.billedUsd;
           sessionCogs += receiptUsedCogs(x);
           noteQuote(x);
           sessionDirect += receiptDirectUsd(x);
-          if (didSpill) {
-            // THE number that settles why a spilled call did or did not save:
-            // the gateway only prices a counterfactual when corpusTokens >
-            // promptTokens, so a tail that rivals the corpus silently falls
-            // back to at-cost and direct collapses onto billed.
-            // Tell-line prints the gateway's actual counterfactual only.
-            // Never fall back to lecore.corpusTokens (often == tokensBefore).
-            log(spillPricedLine(x));
-            spill.spillSpend += x.billedUsd;
-            spill.spillDirect += receiptDirectUsd(x);
-          }
           paidCalls += 1;
           if (viaTunnel) tunnelSpent += x.billedUsd;
           rememberSpend();
           say(`credit -> $${x.billedUsd.toFixed(6)}  ·  session $${sessionSpent.toFixed(6)}`);
         }
         if (data?.object === 'chat.completion') {
-          noteAutoOutcome(response.status, data);
           if (rKey) replayPut(rKey, data, response.headers.get('x-payment-response'));
-          // Anthropic-shaped caller gets an Anthropic-shaped answer, streamed
-          // or not, so Claude Code and the SDKs parse it natively.
-          if (anthropicMode) {
-            const msg = openAIToAnthropic(data, anthropicModel);
-            if (wantsStream) { writeAnthropicSse(res, msg, response); return; }
-            const h = { 'content-type': 'application/json' };
-            const settleHdr = response.headers.get('x-payment-response');
-            if (settleHdr) h['x-payment-response'] = settleHdr;
-            res.writeHead(200, h);
-            res.end(JSON.stringify(msg));
-            return;
-          }
-          if (responsesMode) {
-            // A Responses client that asked to stream is WAITING for
-            // `response.completed`; handing it a JSON body closes the socket
-            // mid-stream and it reports "stream disconnected before
-            // completion". Honour the streaming contract when it asked for it.
-            if (wantsStream) { writeResponsesSse(res, data, responsesModel, response, responsesCustom); return; }
-            const out = chatToResponses(data, responsesModel, responsesCustom);
-            const h = { 'content-type': 'application/json' };
-            const settleHdr = response.headers.get('x-payment-response');
-            if (settleHdr) h['x-payment-response'] = settleHdr;
-            res.writeHead(200, h);
-            res.end(JSON.stringify(out));
-            return;
-          }
           if (wantsStream) { serveAsSse(res, data, response); return; }
           const h = { 'content-type': 'application/json' };
           const settleHdr = response.headers.get('x-payment-response');
@@ -1826,9 +681,6 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       // same figures the JSON path reads out of `data.x402`, same counters, so
       // the status line does not care which transport served the answer.
       const meterStreamed = (x) => {
-        // Same pairing rule as the JSON path: actualUsd / usage.cost with the
-        // settled billed twin, even on a wallet-paid stream (do not skip just
-        // because `paid` already recorded the quote-time receipt).
         const pair = pairActualBilled(x, x?.usage);
         if (pair) {
           sessionActual += pair.upstreamUsd;
@@ -1840,86 +692,11 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         sessionCogs += receiptUsedCogs(x);
         noteQuote(x);
         sessionDirect += receiptDirectUsd(x);
-        if (didSpill) {
-          log(spillPricedLine(x, { streamed: true }));
-          spill.spillSpend += x.billedUsd;
-          spill.spillDirect += receiptDirectUsd(x);
-        }
         paidCalls += 1;
         if (viaTunnel) tunnelSpent += x.billedUsd;
         rememberSpend();
         say(`credit -> $${x.billedUsd.toFixed(6)}  ·  session $${sessionSpent.toFixed(6)}`);
       };
-
-      // RESPONSES CLIENTS (Codex Security) GET THE SAME STREAM, IN THEIR GRAMMAR.
-      // Without this, relay() pipes OpenAI SSE frames at a client waiting for
-      // response.created, and the 10s watchdog fires ("connection interrupted").
-      if (responsesMode && wantsStream
-          && (response.headers.get('content-type') || '').includes('text/event-stream')
-          && response.ok && response.body) {
-        const tr = streamOpenAIToResponses(res, response, responsesModel, responsesCustom);
-        let pending = '';
-        const body = Readable.fromWeb(response.body);
-        res.on('close', () => body.destroy());
-        try {
-          for await (const c of body) {
-            pending += c.toString('utf8');
-            const lines = pending.split('\n');
-            pending = lines.pop() ?? '';
-            for (const line of lines) {
-              if (line.startsWith(': x402 ')) {
-                try { meterStreamed(JSON.parse(line.slice(7))); } catch { /* not ours */ }
-                continue;
-              }
-              if (!line.startsWith('data:')) continue;
-              const payload = line.slice(5).trim();
-              if (!payload || payload === '[DONE]') continue;
-              try { tr.onChunk(JSON.parse(payload)); } catch { /* frame split */ }
-            }
-          }
-        } catch (e) {
-          log(`responses stream aborted: ${e.message}`);
-        }
-        tr.finish();
-        return;
-      }
-
-      // ANTHROPIC CLIENTS GET THE SAME STREAM, IN THEIR OWN GRAMMAR.
-      // Translated frame by frame rather than buffered, so Claude Code sees
-      // tokens as they are produced instead of nothing until the turn ends.
-      if (anthropicMode && wantsStream
-          && (response.headers.get('content-type') || '').includes('text/event-stream')
-          && response.ok && response.body) {
-        const tr = streamOpenAIToAnthropic(res, response, anthropicModel, meterStreamed);
-        let pending = '';
-        const body = Readable.fromWeb(response.body);
-        res.on('close', () => body.destroy());
-        try {
-          for await (const c of body) {
-            pending += c.toString('utf8');
-            const lines = pending.split('\n');
-            pending = lines.pop() ?? '';
-            for (const line of lines) {
-              if (line.startsWith(': x402 ')) {
-                try { meterStreamed(JSON.parse(line.slice(7))); } catch { /* not ours */ }
-                continue;
-              }
-              if (!line.startsWith('data:')) continue;
-              const payload = line.slice(5).trim();
-              if (!payload || payload === '[DONE]') continue;
-              try { tr.onChunk(JSON.parse(payload)); } catch { /* frame split across chunks */ }
-            }
-          }
-        } catch (e) {
-          log(`anthropic stream aborted: ${e.message}`);
-        }
-        tr.finish();
-        return;
-      }
-
-      if (autoRoute) {
-        noteAutoOutcome(response.status, null, (upCt.includes('text/event-stream') && response.ok));
-      }
       await relay(res, response, meterStreamed);
     } catch (err) {
       if (err instanceof QuoteTooHighError) {
@@ -1930,8 +707,8 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         jsonErr(res, 402, err.message);
       } else {
         // "fetch failed" alone is undiagnosable — undici hides the real
-        // network error in `cause`. Surface it (and log the stack) or every
-        // transport hiccup looks identical to a payment bug.
+        // network error in `cause`. Surface it or every transport hiccup looks
+        // identical to a payment bug.
         const cause = err.cause?.message || err.cause?.code || err.cause;
         const raw = cause ? `${err.message} (${cause})` : err.message;
         const detail = raw;
@@ -1943,22 +720,15 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
   });
 
   // BIND HOST. Default 127.0.0.1 — the keyless localhost path must never be
-  // world-reachable on an ordinary machine. A RunPod box is the exception: its
-  // HTTP proxy reaches the container over the pod network, so a localhost bind
-  // shows "Initializing…" forever (MEASURED: podagent's 0.0.0.0 ports went
-  // Ready, the 127.0.0.1 proxy never did). The box sets OPENZOO_BIND=0.0.0.0
-  // AND a tunnel token, so the RunPod-fronted port stays gated exactly like the
-  // public tunnel path.
+  // world-reachable on an ordinary machine. A RunPod box sets
+  // OPENZOO_BIND=0.0.0.0 AND a tunnel token, so that port stays gated exactly
+  // like the public tunnel path.
   const bindHost = process.env.OPENZOO_BIND || '127.0.0.1';
-  // SELF-HEAL A TAKEN PORT. A killed-but-not-reaped run, a second terminal, or
-  // anything else already on 8402 made listen() reject and took the whole start
-  // down — and because `openzoo claude` starts us with silent:true, the user saw
-  // only "starting the proxy in the background..." and no reason. Walk up to the
-  // next free port instead of dying; the caller reads config.port back out, so
-  // every URL printed afterwards is the one we actually bound.
-  //
-  // EXCEPTION: if the thing already on the port is a HEALTHY openzoo proxy,
-  // reuse it rather than starting a rival that splits spend across two wallets.
+  // SELF-HEAL A TAKEN PORT. Walk up to the next free port instead of dying;
+  // the caller reads config.port back out, so every URL printed afterwards is
+  // the one we actually bound. EXCEPTION: if the thing already on the port is
+  // a HEALTHY openzoo proxy, reuse it rather than starting a rival that splits
+  // spend across two wallets.
   const wanted = config.port;
   for (let attempt = 0; ; attempt++) {
     try {
@@ -1985,23 +755,12 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
   }
   if (config.port !== wanted) say(`openzoo: listening on :${config.port} (:${wanted} was busy)`);
 
-  // AUTO-PREPAY. Paying on-chain per call is where the latency lives: the
-  // gateway answers its 402 challenge in ~0.12s while a full settled call
-  // MEASURED 9-37s end to end. Credit is applied automatically server-side
-  // whenever a balance covers the quote, so buying it once makes every later
-  // call skip verify+settle entirely.
-  //
-  // Runs in the background — never block the listener on a payment — and only
-  // when this wallet actually has funds, so a fresh/empty wallet is untouched.
+  // AUTO-PREPAY. Paying on-chain per call is where the latency lives: credit
+  // is applied automatically server-side whenever a balance covers the quote,
+  // so buying it once makes every later call skip verify+settle entirely.
+  // Runs in the background and only when this wallet actually has funds.
   // Opt out with OPENZOO_NO_AUTOTOPUP=1; size it with OPENZOO_AUTOTOPUP_USD.
   if (!process.env.OPENZOO_NO_AUTOTOPUP) {
-    // Keep credit topped up, forever, from whatever the wallet holds.
-    //
-    // The first version ran ONCE at startup and bought a fixed $5, so funding
-    // the wallet later did nothing at all — the user sent TOKEN and kept
-    // paying on-chain per call. This checks on an interval and spends what the
-    // wallet can actually cover, priced by the gateway's own live quote (so
-    // TOKEN is valued exactly as it settles).
     const FLOOR = Number(process.env.OPENZOO_AUTOTOPUP_FLOOR || 2);
     const EVERY = Number(process.env.OPENZOO_AUTOTOPUP_EVERY_MS || 60_000);
     let topping = false;
@@ -2029,19 +788,14 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
 
   if (!silent) {
     // VERSION IN THE BANNER, deliberately. `npx openzoo` can serve a STALE
-    // cached copy — npx reuses a cache entry that matches the bare spec, so a
-    // user running the newest published version still gets old behaviour and
-    // no clue why (observed: a missing tunnel and a missing token row, both
-    // "fixed" releases ago). Printing the version makes that one glance.
+    // cached copy; printing the version makes that one glance.
     const { version } = JSON.parse(
       readFileSync(new URL('../package.json', import.meta.url), 'utf8'),
     );
     console.log(`openzoo v${version}  ->  ${config.apiBase}`);
     console.log(`listening on   http://localhost:${config.port}/v1`);
-    // LAND THEM IN THE APP. `npx openzoo` in a human terminal opens the chat
-    // GUI — a stranger's first 8 seconds should be a working chat, not a URL
-    // to notice. Never in CI/agents (no TTY), never twice, opt out with
-    // OPENZOO_NO_OPEN=1.
+    // LAND THEM IN THE APP. Never in CI/agents (no TTY), never twice, opt out
+    // with OPENZOO_NO_OPEN=1.
     if (process.stdout.isTTY && !process.env.OPENZOO_NO_OPEN) {
       const opener = process.platform === 'darwin' ? 'open'
         : process.platform === 'win32' ? 'start' : 'xdg-open';
@@ -2061,10 +815,8 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
     } catch { /* RPC hiccup: balance is advisory */ }
     refreshCredit();
     refreshPrices();
-    // LIVE REFRESH: the startup line goes stale the moment a call settles or
-    // the user funds mid-session. Poll on an interval (and shortly after each
-    // paid call), print ONLY on change, and call out arrivals explicitly so
-    // "did my top-up land?" answers itself in the running log.
+    // LIVE REFRESH: poll on an interval (and shortly after each paid call),
+    // print ONLY on change, and call out arrivals explicitly.
     refreshBalances = async () => {
       try {
         const snap = await snapshotBalances(client);
@@ -2094,12 +846,8 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       const rails = await liveRails();
       if (rails) {
         console.log(`rails live now: ${rails.live.join(' · ')}`);
-        // Funding advice is derived from those rails, never hardcoded — the
-        // zoo can add a chain without this package shipping again.
         const hint = railFundingHint(rails.live);
         if (hint) console.log(`fund with:      ${hint}`);
-        // The exact contracts those symbols mean — every chain has impersonator
-        // mints, so a symbol without its CA is an invitation to fund the wrong one.
         for (const row of railFundingAddresses(rails.live)) {
           row.assets.forEach((a, i) => {
             const label = i === 0 ? row.label : '';
@@ -2143,10 +891,6 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         process.once('SIGTERM', () => { bye(); process.exit(0); });
         process.once('exit', bye);
         log('');
-        if (boundCharsRestored) {
-          const tot = [...boundChars.values()].reduce((a, b) => a + b, 0);
-          log(`corpus ledger restored: ${boundCharsRestored} context(s), ${mb(tot)}MB bound — counterfactual survives restarts`);
-        }
         log('cloud IDE / remote harness? use the public URL (they cannot reach localhost):');
         log(`  base_url = ${url}/v1`);
         log(`  api_key  = ${token}`);
@@ -2154,17 +898,15 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         log('   OPENZOO_NO_TUNNEL=1 for localhost-only)');
       } catch (err) {
         // Record it: a caller polling for publicUrl (openzoo cursor) would
-        // otherwise spin the full timeout on a tunnel that already died, with
-        // silent:true swallowing this very message.
+        // otherwise spin the full timeout on a tunnel that already died.
         tunnelError = err.message;
         log(`public URL unavailable (${err.message}) — localhost still works; OPENZOO_NO_TUNNEL=1 hides this line`);
       }
     })();
   }
   // Expose live tunnel details so a caller that starts the proxy in-process
-  // (openzoo cursor/vscode) can surface the public URL + key instead of the
-  // user hunting for them. Getters, because the tunnel resolves ASYNC after
-  // this returns — a snapshot would always be null.
+  // (openzoo cursor/vscode) can surface the public URL + key. Getters, because
+  // the tunnel resolves ASYNC after this returns.
   return {
     server,
     client,