openzoo 0.49.5 → 0.49.7

package/README.md

@@ -79,7 +79,7 @@ claude mcp add openzoo -- npx -y openzoo mcp
 **Windsurf / Cline / any MCP host** — same shape: command `npx`, args `["-y", "openzoo", "mcp"]`, stdio transport.
 
 Tools:
-- **`zoo_ask`** — `{prompt, corpus?, model?, max_tokens?}`. The flagship: hand it a *huge* `corpus` (hundreds of thousands to ~1M tokens — a body the model itself would refuse) and a question; the zoo's leCore memory spills the corpus so the model reads only a few thousand tokens. Returns the answer plus the receipt (`billedUsd`, `savesVsDirect`, tokens actually read). An MCP-capable agent can delegate a giant-context question without touching its own model config.
+- **`zoo_ask`** — `{prompt, corpus?, model?, max_tokens?}`. The flagship: hand it a *huge* `corpus` (hundreds of thousands to ~1M tokens — a body the model itself would refuse) and a question; the zoo's leCore memory spills the corpus so the model reads only a few thousand tokens. Returns the answer plus the receipt (`billedUsd`, `directUsd`, `savedUsd`, tokens actually read). An MCP-capable agent can delegate a giant-context question without touching its own model config.
 - **`zoo_models`** — list the zoo's models and pricing (free).
 - **`zoo_wallet`** — funding address, balances, and this session's receipts.
 
@@ -93,7 +93,7 @@ Builds a ~965k-token document with one planted fact, shows that buying direct re
 
 ```
 bound once in 14.8s: 3.7MB → context ctx_01KZZY8YQE…
-quote for the ask: $0.000480 · pricing=markup (a tiny body — the 3.7MB corpus is not re-priced)
+quote for the ask: $0.000480 · pricing=markup · at OpenRouter price (the 3.7MB corpus is not re-priced)
 ```
 
 If the wallet is funded with USDC or TOKEN it pays (capped at `OPENZOO_DEMO_MAX_USD`, default $0.01) and prints the answer, the tokens the model actually read, and the receipt. If not, it prints exactly what to fund. Long waits (the one-time upload, pricing, payment, the answer) show a live progress line with stage + elapsed seconds.
@@ -111,7 +111,7 @@ If the wallet is funded with USDC or TOKEN it pays (capped at `OPENZOO_DEMO_MAX_
 The zoo keeps your corpus in leCore holographic memory; the shim keeps a manifest at `~/.openzoo/contexts.json` (chmod 600) mapping `sha256(corpus)` → the zoo's `context_id`, scoped per API base. When a request carries a corpus the manifest already knows:
 
 - **nothing big is uploaded** — the ask ships alone with an `X-HRR-Context` header,
-- **the 402 prices the tiny ask** (honestly labeled `pricing=markup`), typically a few hundredths of a cent instead of re-pricing megabytes,
+- **the 402 prices the tiny ask** at OpenRouter rates (read `extra.billedUsd`), typically a few hundredths of a cent instead of re-pricing megabytes,
 - **the answer still comes from your corpus** — the zoo recalls the relevant slices server-side.
 
 This works in all three fronts: the **proxy** (a big pasted body in the last message is split at its last blank line, bound once, and reused on every later call — even with a different question), the **MCP** `zoo_ask` `corpus` parameter, and the **demo**. If the zoo ever forgets a context (sidecar wipe), the gateway answers 404 *before* any payment and the shim transparently re-binds once and retries — a stale manifest never fails a call.
@@ -175,11 +175,11 @@ Pin the key with `OPENZOO_TUNNEL_TOKEN` if your IDE stores it. Keys never leave
 ## Honest pricing note
 
 Two bases, reported per call in the 402 (`extra.pricing`):
-- **Short prompts price at cost.** There's nothing to spill, so there's no saving to share — you pay what the call cost us, reconciled against the provider's own metered figure after it completes.
-- **Big bodies price at a counterfactual discount** (~10× cheaper than buying the same call direct) — the zoo's leCore memory means it never forwards your whole body upstream, and passes the savings on. Measured numbers at [benches.openzoo.fun](https://benches.openzoo.fun).
-- **Asks against a bound corpus price on the small forwarded body** (the receipt says `pricing=markup`). That is not a discount trick: a few hundred tokens at cost is far below the counterfactual price of shipping the corpus, which is the whole point of binding once.
+- **Wallet path charges OpenRouter prices.** There is no 3× markup. If the caller saves vs sending the same body direct, zoo takes 33% of the savings. Short prompts have nothing to spill, so you pay the OpenRouter figure, reconciled against the provider's own metered cost after it completes.
+- **Big bodies price at a counterfactual discount** (~10× cheaper than buying the same call direct) — the zoo's leCore memory means it never forwards your whole body upstream, and passes most of the savings on. Measured numbers at [benches.openzoo.fun](https://benches.openzoo.fun).
+- **Asks against a bound corpus price on the small forwarded body.** That is not a discount trick: a few hundred tokens at OpenRouter rates is far below the counterfactual price of shipping the corpus, which is the whole point of binding once.
 
-The receipt names which base you got; `extra.directUsd` / `extra.savesVsDirect` let you check the math.
+The receipt names which base you got; `extra.billedUsd` / `extra.directUsd` / `extra.savedUsd` let you check the math. (Card subscription pricing is a different path.)
 
 ## Payment rails
 

package/lib/boxes.js

@@ -77,7 +77,7 @@ const ENTRYPOINT = [
   // its HTTP port mappings). The app is read-only at runtime; mutable state
   // lives in /root/.openzoo.
   + 'until OPENZOO_BIND=0.0.0.0 node /opt/openzoo/bin/openzoo.js >> /var/log/openzoo/proxy.log 2>&1; do echo "proxy exited, restarting" >> /var/log/openzoo/proxy.log; sleep 2; done & '
-  + 'until OZ_GROKUI_BIND=0.0.0.0 OZ_GROKUI_PORT=4173 node /opt/grokui/grokui.mjs >> /var/log/openzoo/grokui.log 2>&1; do echo "grokui exited, restarting" >> /var/log/openzoo/grokui.log; sleep 2; done & '
+  + 'until OZ_GROKUI_BIND=0.0.0.0 OZ_GROKUI_PORT=4173 node /opt/openzoo/lib/grokui.mjs >> /var/log/openzoo/grokui.log 2>&1; do echo "grokui exited, restarting" >> /var/log/openzoo/grokui.log; sleep 2; done & '
   // the capture agent answers the ports Grok Bot expects a Cursor sandbox on,
   // logging the protocol we do not yet speak (see lib/podagent.mjs)
   + 'if [ -n "$OZ_PODAGENT_B64" ]; then printf %s "$OZ_PODAGENT_B64" | base64 -d > /opt/podagent.mjs; node /opt/podagent.mjs > /var/log/openzoo/agent.log 2>&1 & fi; '

package/lib/demo.js

@@ -120,7 +120,10 @@ export async function runDemo() {
   }
   const accept = pickAccept(quote, config.token);
   const x = accept.extra || {};
-  console.log(`   quote for the ask: $${Number(x.billedUsd).toFixed(6)} · pricing=${x.pricing} (3× a tiny body — the ${docMb}MB corpus is not re-priced)`);
+  const saved = x.savedUsd != null ? Number(x.savedUsd)
+    : (x.directUsd != null ? Math.max(0, Number(x.directUsd) - Number(x.billedUsd)) : 0);
+  const saveBit = saved > 0 ? ` · $${saved.toFixed(6)} saved vs direct` : ' · at OpenRouter price';
+  console.log(`   quote for the ask: $${Number(x.billedUsd).toFixed(6)} · pricing=${x.pricing}${saveBit} (the ${docMb}MB corpus is not re-priced)`);
   console.log('');
 
   if (Number(x.billedUsd) > config.demoMaxUsd) {

package/lib/grokui.mjs

@@ -24,6 +24,13 @@ import {
   prepareChildDir, finishChildDir, lockWorktree, unlockWorktree,
   parsePrRef, fetchSpecsForOrigin, agentSlug,
 } from './worktree.mjs';
+import {
+  filesForCorpus as collectFilesForCorpus,
+  readFilesForCorpus,
+  looksLikeFileView,
+  extractBashPaths,
+} from './spill.js';
+import { BIND_MIN_CHARS } from './hrr.js';
 
 const PORT = Number(process.env.OZ_GROKUI_PORT || 4173);
 // BIND HOST. Default 127.0.0.1 so the desktop app never exposes a shell-capable
@@ -391,8 +398,9 @@ comes back with content:null and finish_reason:"length" (confirmed live) if you
 to append to the same bound context, rather than one giant request that silently fails partway.
 
 COST ACCOUNTING — do NOT compute this yourself from token counts. Every response carries an
-"x402" object; read the numbers off it: x402.billedUsd (what the user paid), x402.cogsUsd
-(our upstream cost), x402.directUsd (what answering WITHOUT the zoo would have cost), and
+"x402" object; read the numbers off it: x402.billedUsd (what the user paid — OpenRouter price, plus 33% of savings vs
+direct when any), x402.cogsUsd (our upstream cost), x402.directUsd (what answering
+WITHOUT the zoo would have cost), x402.savedUsd (dollars saved), and
 x402.savesVsDirect (the multiple). Summing usage.cost or usage.prompt_tokens and comparing
 that to a provider's list price is WRONG and understates the saving enormously: against a
 bound context, prompt_tokens counts only the small slice leCore recalled, NOT the corpus
@@ -401,7 +409,7 @@ the zoo "cost more". MEASURED: a real 21-question run reported 202,238 prompt to
 each attach call stood in for a 5,356,546-token corpus — a 556x understatement, and that
 corpus is ~42x larger than the model's own context window, so the "direct" comparison it
 was measured against was not merely pricier but IMPOSSIBLE. When the user asks what they
-saved, quote x402.directUsd and x402.savesVsDirect. If savesVsDirect is below 1x, say so
+saved, quote x402.billedUsd, x402.directUsd and x402.savedUsd. If savedUsd is 0 / savesVsDirect is below 1x, say so
 plainly — that happens on small inputs, where the corpus is too small to save anything.
 For normal questions just answer directly — do not use any of these unless the request
 actually calls for delegation or file work.`;
@@ -618,7 +626,7 @@ this is roleplay, and never fabricate command output or receipts. A real failure
 as real output and an exit code, not as silence.
 
 COST ACCOUNTING — read it off the response's "x402" object (billedUsd, cogsUsd, directUsd,
-savesVsDirect). Never derive it by summing usage.cost or usage.prompt_tokens against a
+savedUsd, savesVsDirect). Never derive it by summing usage.cost or usage.prompt_tokens against a
 provider's list price: on a bound context prompt_tokens counts only the slice leCore
 recalled, not the corpus it stands in for, so that math prices the discount against itself
 and wrongly concludes the zoo cost more.
@@ -1123,6 +1131,159 @@ function condense(label, text) {
   return `${label}\n${head}\n\n…[${s.length - head.length - tail.length} chars elided from THIS message — the full output is bound to this thread's holographic memory. It is not lost: mention what you need in your next message and the relevant part is retrieved automatically. Do not invent a command to fetch it.]…\n\n${tail}`;
 }
 
+// Files the grokui agent READ/WRITE/EDIT/MULTIEDIT/NOTEBOOK'd (and RUN
+// cat/head/type) must land in the HRR corpus as path-prefixed file parts —
+// not as unlabeled chat text via bindThread, and not as the ~3k condense()
+// stub the next completion sends. Sidecar maybeCacheCorpus only sees that
+// stub; bindThread never labels them as files. filesForCorpus (spill.js)
+// already dedups path:mtime and caps at KEEP_MAX (400KB). We reuse it.
+const boundFiles = new Set();
+
+function pathToReadMsgs(paths) {
+  return (Array.isArray(paths) ? paths : [paths]).filter(Boolean).map((file_path) => ({
+    role: 'assistant',
+    tool_calls: [{
+      function: { name: 'Read', arguments: JSON.stringify({ file_path }) },
+    }],
+  }));
+}
+
+function commandToBashMsgs(command) {
+  return [{
+    role: 'assistant',
+    tool_calls: [{
+      function: { name: 'Bash', arguments: JSON.stringify({ command }) },
+    }],
+  }];
+}
+
+/**
+ * Collect grokui file reads/writes for the HRR corpus.
+ *
+ * Accepts an absolute/relative path, a list of paths, or already-shaped
+ * chat messages (OpenAI tool_calls / Anthropic tool_use). Dedup and the
+ * 400KB cap live in spill.js — this is the grokui entry point so READ
+ * records the same way Claude Code Read does.
+ */
+function filesForCorpus(target, opts = {}) {
+  const keys = opts.boundFiles || boundFiles;
+  const cwd = opts.cwd || process.cwd();
+  const cap = opts.cap ?? KEEP_MAX;
+  let msgs = target;
+  if (typeof target === 'string') msgs = pathToReadMsgs(target);
+  else if (Array.isArray(target) && (target.length === 0 || typeof target[0] === 'string')) {
+    msgs = pathToReadMsgs(target);
+  }
+  return collectFilesForCorpus(msgs, { ...opts, boundFiles: keys, cwd, cap });
+}
+
+function filesForCorpusKeys() {
+  return boundFiles;
+}
+
+function resetFilesForCorpus() {
+  boundFiles.clear();
+}
+
+function inFlightChars(t) {
+  if (!t) return 0;
+  if (Array.isArray(t.messages)) {
+    let n = 0;
+    for (const m of t.messages) {
+      const c = m?.content;
+      if (typeof c === 'string') n += c.length;
+      else if (c != null) n += JSON.stringify(c).length;
+    }
+    return n;
+  }
+  let n = 0;
+  for (const h of t.history || []) n += String(h?.text || '').length;
+  return n;
+}
+
+/**
+ * POST file bytes to ${PROXY}/hrr/bind, appending to the project context.
+ * Always fire-and-forget so a READ does not wait on the bind round-trip.
+ * When the in-flight corpus/messages are below BIND_MIN_CHARS the bind
+ * still happens — reuse only "wins" on a big body, but the file must be
+ * recallable next turn. Completions keep omitting x-hrr-context.
+ */
+function scheduleFilesForCorpus(t, collected, opts = {}) {
+  if (!collected?.pending?.length) return null;
+  const root = t ? (threads.get(rootOf(t).rootId) || t) : null;
+  const ctx = opts.contextId || root?.contextId || t?.contextId || null;
+  const chars = opts.sentChars ?? inFlightChars(t);
+  const background = chars < BIND_MIN_CHARS;
+  const fetchImpl = opts.fetchImpl || fetch;
+  const run = () => {
+    let read;
+    try { read = readFilesForCorpus(collected, { boundFiles: opts.boundFiles || boundFiles, cap: opts.cap ?? KEEP_MAX }); }
+    catch { return Promise.resolve(null); }
+    if (!read?.text) return Promise.resolve(null);
+    const payload = ctx ? { corpus: read.text, context_id: ctx } : { corpus: read.text };
+    return fetchImpl(`${PROXY}/hrr/bind`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify(payload),
+    }).then(async (r) => {
+      const j = await r.json().catch(() => ({}));
+      if (j?.context_id && t) {
+        const live = threads.get(rootOf(t).rootId) || t;
+        live.contextId = j.context_id;
+        t.contextId = j.context_id;
+        if (Number(j.bound)) live.boundItems = (live.boundItems || 0) + Number(j.bound);
+      }
+      return j;
+    }).catch(() => null);
+  };
+  const job = { pending: collected.pending, background, append: Boolean(ctx), run };
+  const kick = () => { job.promise = run(); };
+  if (opts.defer === false) kick();
+  else setImmediate(kick);
+  return job;
+}
+
+function noteFileForCorpus(originId, relOrAbs, extra = {}) {
+  const t = extra.thread || (originId ? threads.get(originId) : null);
+  const cwd = extra.cwd || (originId ? dirFor(originId) : process.cwd());
+  let abs = relOrAbs;
+  if (typeof abs === 'string' && !path.isAbsolute(abs)) {
+    try { abs = originId ? safeResolveIn(cwd, abs) : path.resolve(cwd, abs); }
+    catch { abs = path.resolve(cwd, abs); }
+  }
+  const collected = filesForCorpus(abs, {
+    cwd,
+    boundFiles: extra.boundFiles || boundFiles,
+    cap: extra.cap ?? KEEP_MAX,
+    ...(extra.collectOpts || {}),
+  });
+  return scheduleFilesForCorpus(t, collected, extra);
+}
+
+function noteRunForCorpus(originId, command, extra = {}) {
+  if (!looksLikeFileView(command)) return null;
+  const t = extra.thread || (originId ? threads.get(originId) : null);
+  const cwd = extra.cwd || (originId ? dirFor(originId) : process.cwd());
+  const collected = filesForCorpus(commandToBashMsgs(command), {
+    cwd,
+    boundFiles: extra.boundFiles || boundFiles,
+    cap: extra.cap ?? KEEP_MAX,
+  });
+  if (!collected.pending.length) {
+    const { paths } = extractBashPaths(command, cwd);
+    const abs = paths.map((p) => {
+      const raw = p?.raw;
+      if (!raw) return null;
+      if (path.isAbsolute(raw)) return raw;
+      try { return originId ? safeResolveIn(p.cwd || cwd, raw) : path.resolve(p.cwd || cwd, raw); }
+      catch { return path.resolve(p.cwd || cwd, raw); }
+    }).filter(Boolean);
+    if (!abs.length) return null;
+    return noteFileForCorpus(originId, abs, extra);
+  }
+  return scheduleFilesForCorpus(t, collected, extra);
+}
+
 // threadId -> open SSE responses. A Set because the same thread can be open in
 // two tabs, and both should see the same tokens.
 const streamListeners = new Map();
@@ -2095,6 +2256,7 @@ async function tryDirective(reply, originId, onEvent) {
       const full = safeResolveIn(dirFor(originId), rel);
       mkdirSync(path.dirname(full), { recursive: true });
       writeFileSync(full, content);
+      noteFileForCorpus(originId, full);
       return `Wrote ${rel} (${Buffer.byteLength(content)} bytes) to ${dirFor(originId)}.${await previewAck(originId, rel)}`;
     } catch (e) { return `Couldn't write ${rel}: ${e.message}`; }
   }
@@ -2102,7 +2264,9 @@ async function tryDirective(reply, originId, onEvent) {
   if (readD) {
     const rel = readD[1].trim();
     try {
-      const data = readFileSync(safeResolveIn(dirFor(originId), rel), 'utf8');
+      const full = safeResolveIn(dirFor(originId), rel);
+      const data = readFileSync(full, 'utf8');
+      noteFileForCorpus(originId, full);
       return `${rel}:\n${keepWhole(data)}`;
     } catch (e) { return `Couldn't read ${rel}: ${e.message}`; }
   }
@@ -2121,6 +2285,7 @@ async function tryDirective(reply, originId, onEvent) {
       if (hits === 0) return `EDIT ${rel}: that exact text isn't in the file — READ it first, the copy must match byte for byte.`;
       if (hits > 1) return `EDIT ${rel}: that text appears ${hits} times — include more surrounding context so it matches exactly once.`;
       writeFileSync(full, before.replace(oldStr, newStr));
+      noteFileForCorpus(originId, full);
       return `Edited ${rel} (${before.length} -> ${before.replace(oldStr, newStr).length} bytes).${await previewAck(originId, rel)}`;
     } catch (e) { return `Couldn't edit ${rel}: ${e.message}`; }
   }
@@ -2147,6 +2312,7 @@ async function tryDirective(reply, originId, onEvent) {
         applied.push(o.slice(0, 40));
       }
       writeFileSync(full, next);
+      noteFileForCorpus(originId, full);
       return `MULTIEDIT ${rel}: ${applied.length} edit(s) applied (${before.length} -> ${next.length} bytes).${await previewAck(originId, rel)}`;
     } catch (e) { return `Couldn't multiedit ${rel}: ${e.message}`; }
   }
@@ -2167,6 +2333,7 @@ async function tryDirective(reply, originId, onEvent) {
       // Stale outputs next to new code are worse than none.
       if (doc.cells[idx].cell_type === 'code') { doc.cells[idx].outputs = []; doc.cells[idx].execution_count = null; }
       writeFileSync(full, JSON.stringify(doc, null, 1));
+      noteFileForCorpus(originId, full);
       return `NOTEBOOK ${rel}: replaced cell ${idx} (${doc.cells[idx].cell_type}); outputs cleared.`;
     } catch (e) { return `Couldn't edit ${rel}: ${e.message}`; }
   }
@@ -2520,6 +2687,7 @@ async function runTurn(threadId, userText, onEvent, images) {
         if (t.runMode === 'auto') {
           emitLiveStatus(t.id, paint, peekDirectiveStatus('', command));
           const output = await execCommand(command, dirFor(t.id));
+          noteRunForCorpus(t.id, command, { cwd: dirFor(t.id) });
           const shown = `$ ${command}\n${output}`;
           t.history.push({ who: 'bot', text: shown, name: m.name, color: m.color });
           paint({ type: 'final', name: m.name, color: m.color, text: shown });
@@ -2663,6 +2831,7 @@ async function runTurn(threadId, userText, onEvent, images) {
     if (t.runMode === 'auto') {
       emitLiveStatus(t.id, paint, peekDirectiveStatus('', command));
       const output = await execCommand(command, dirFor(t.id));
+      noteRunForCorpus(t.id, command, { cwd: dirFor(t.id) });
       if (!stillMine()) return;
       const shown = `$ ${command}\n${output}`;
       t.history.push({ who: 'bot', text: shown });
@@ -5614,6 +5783,7 @@ const server = http.createServer((req, res) => {
       res.writeHead(200, { 'content-type': 'application/json' });
       res.end('{"ok":true}');
       execCommand(command, cwd).then((output) => {
+        noteRunForCorpus(t.id, command, { cwd });
         entry.runStatus = 'done';
         entry.runOutput = output;
         saveThreads();
@@ -5722,4 +5892,6 @@ export {
   isDoneReply, isTransientModelFail, isEmptyToolResult, enqueueAutoHop, childKickoff, findByName,
   attachChildDir, finishChildDir,
   lockWorktree, unlockWorktree, parsePrRef, fetchSpecsForOrigin, agentSlug,
+  filesForCorpus, noteFileForCorpus, noteRunForCorpus, resetFilesForCorpus,
+  filesForCorpusKeys, scheduleFilesForCorpus, inFlightChars, BIND_MIN_CHARS, KEEP_MAX,
 };

package/lib/gui.html

@@ -194,7 +194,10 @@ async function send() {
     const x = d.x402 || {};
     state.calls += 1;
     if (typeof x.billedUsd === "number") state.spent += x.billedUsd;
-    if (typeof x.savesVsDirect === "number" && x.savesVsDirect > 0) state.saved += x.savesVsDirect;
+    if (typeof x.savedUsd === "number" && x.savedUsd > 0) state.saved += x.savedUsd;
+    else if (typeof x.directUsd === "number" && typeof x.billedUsd === "number") {
+      state.saved += Math.max(0, x.directUsd - x.billedUsd);
+    }
     const bits = [];
     if (typeof x.billedUsd === "number") bits.push(`$${x.billedUsd.toFixed(4)}`);
     if (x.lecore?.engaged) bits.push(`🧠 ${x.lecore.recalled ?? "?"} slices`);

package/lib/mcp.js

@@ -80,7 +80,7 @@ export function buildMcpServer() {
       + '(client-usable ceiling ~128M tokens; keep one call under ~9.8M) is bound once and the model reads only '
       + 'a few thousand tokens of it. Re-asking against an already-bound corpus is near-free and much faster, so '
       + 'send the corpus once and ask many questions. Returns the answer plus a payment receipt '
-      + '(billedUsd, savesVsDirect, tokens actually read).',
+      + '(billedUsd, directUsd, savedUsd, tokens actually read).',
     inputSchema: {
       prompt: z.string().describe('The question or instruction.'),
       corpus: z.string().optional().describe('Optional big context body (document dump, logs, book...). Placed before the prompt.'),
@@ -128,6 +128,8 @@ export function buildMcpServer() {
         receipt: receipt ? {
           line: receipt.line,
           billedUsd: receipt.billedUsd,
+          directUsd: receipt.directUsd,
+          savedUsd: receipt.savedUsd,
           savesVsDirect: receipt.savesVsDirect,
           pricing: receipt.pricing,
           rail: receipt.rail,

package/lib/models.js

@@ -323,10 +323,24 @@ export function isTinyClassify(body, bodyLen) {
   return messages.length <= CLASSIFY_MAX_MSGS && len < CLASSIFY_MAX_BODY;
 }
 
+/**
+ * Ids that must never serve Claude Code / grokui AUTO's tiny yes/no classify.
+ * REASONING_MODEL_RE is the thinking floor; HEAVY_RE is the flagship set
+ * (opus/pro/max/…). opus-5 is openzoo's default session model and does NOT
+ * match the reasoning regex, so a catalog that lists opus before flash — or
+ * lists only opus + grok — used to pick opus as "first non-reasoner". That
+ * classify is a 402 handshake on a big model; AUTO's timeout then hard-blocks
+ * Bash instead of prompting.
+ */
+function isSlowClassifier(id) {
+  const s = String(id || '');
+  return REASONING_MODEL_RE.test(s) || HEAVY_RE.test(s);
+}
+
 /**
  * Fast non-reasoning id that is actually on the zoo. Prefer an explicit
  * OPENZOO_CLASSIFIER_MODEL, then flash, then haiku, then the first catalog
- * id that does not match the reasoning regex.
+ * id that is neither a reasoner nor a heavy/flagship (opus/pro/max/…).
  */
 export function pickClassifierModel(ids, preferred = process.env.OPENZOO_CLASSIFIER_MODEL) {
   if (!Array.isArray(ids) || !ids.length) return null;
@@ -334,7 +348,7 @@ export function pickClassifierModel(ids, preferred = process.env.OPENZOO_CLASSIF
   for (const id of CLASSIFIER_PREFS) {
     if (ids.includes(id)) return id;
   }
-  return ids.find((id) => !REASONING_MODEL_RE.test(id)) || null;
+  return ids.find((id) => !isSlowClassifier(id)) || null;
 }
 
 /**
@@ -362,14 +376,22 @@ export function raiseReasoningMaxTokens(parsed, env = process.env) {
  * Model + max_tokens policy for one chat body.
  *
  * Tiny classify: pin to a fast non-reasoning catalog id, leave max_tokens
- * alone, ignore OPENZOO_DEFAULT_MODEL. Everything else: resolveModel (which
- * honours the default) then the reasoning floor.
+ * alone, ignore OPENZOO_DEFAULT_MODEL. Never fall back to `from` when that
+ * id is a reasoner or a heavy/flagship (the zoo default is opus-5). A
+ * catalog miss or an opus-only list used to keep the classify on opus-5
+ * and AUTO hard-blocked Bash. Everything else: resolveModel (which honours
+ * the default) then the reasoning floor.
  */
 export function rewriteChatModel(parsed, ids, { bodyLen } = {}) {
   const from = parsed?.model;
   const len = bodyLen ?? (parsed == null ? 0 : Buffer.byteLength(JSON.stringify(parsed)));
   if (isTinyClassify(parsed, len)) {
-    const to = (typeof from === 'string' && pickClassifierModel(ids)) || from;
+    const picked = pickClassifierModel(ids);
+    // pickClassifierModel returns null on an empty catalog or a zoo that
+    // only lists reasoners/heavies. `(picked) || from` left those on
+    // anthropic/claude-opus-5 (openzoo's default). Pin to flash instead —
+    // never ship a classify body AUTO would time out and hard-block on.
+    const to = picked || (typeof from === 'string' && !isSlowClassifier(from) ? from : CLASSIFIER_PREFS[0]);
     return {
       parsed: (to && to !== from) ? { ...parsed, model: to } : parsed,
       tiny: true,

package/lib/pay.js

@@ -413,6 +413,9 @@ export class PayClient {
       line: receiptLine(accept, settle),
       rail: railOf(accept),
       billedUsd: accept.extra?.billedUsd,
+      directUsd: accept.extra?.directUsd,
+      savedUsd: accept.extra?.savedUsd,
+      cogsUsd: accept.extra?.cogsUsd,
       savesVsDirect: accept.extra?.savesVsDirect,
       pricing: accept.extra?.pricing,
       symbol: accept.extra?.symbol,