openzoo 0.50.0 → 0.50.2

package/lib/xbot.js

@@ -25,6 +25,24 @@ import { FUNDING_ASSETS } from './config.js';
 import { deriveBurner } from './xburner.js';
 
 const GATEWAY = process.env.OPENZOO_GATEWAY || 'https://x402-tokens.fly.dev';
+/**
+ * WHERE THE FREE LANE BUYS ITS ANSWER.
+ *
+ * The free question used to ride a SUBSCRIPTION KEY against the gateway. There
+ * are no subscriptions any more — `X402_ONLY=1` kills the lane in subs.ts, so
+ * `resolveSub()` returns null and the gateway answers 402 to a key that used to
+ * work. OBSERVED live: `billing: subscription key` immediately followed by
+ * `answer failed: gateway 402`, retried 3x, and the asker got nothing.
+ *
+ * So the free lane now goes through the LOCAL openzoo proxy, which settles x402
+ * from the operator's own wallet. "Free" was always us paying — this just makes
+ * which wallet pays explicit instead of routing it through a lane that no
+ * longer exists. The paid lane is untouched: it still hits GATEWAY directly
+ * with the asker's own burner.
+ */
+const FREE_GATEWAY = process.env.OPENZOO_XBOT_FREE_GATEWAY
+  || process.env.OPENZOO_PROXY_URL
+  || 'http://localhost:8402';
 
 /**
  * THIS BOT MAKES SLOW CALLS, AND THE DEFAULT TIMEOUT ASSUMES IT DOES NOT.
@@ -87,7 +105,13 @@ const WEB_SEARCH = process.env.OPENZOO_XBOT_WEB === '1';
  * on Twitter. Free lane keeps search on: that runs on our own subscription, so
  * the cost is ours to choose. Set OPENZOO_XBOT_WEB_PAID=1 to enable it there.
  */
+/** @deprecated Read by nothing since Brave grounding replaced the paid
+ *  OpenRouter plugin (2026-08-26). It existed to keep a $0.075 surcharge off
+ *  the asker's wallet; that surcharge is gone, so both lanes ground equally.
+ *  Kept so an existing OPENZOO_XBOT_WEB_PAID=1 in someone's env is inert
+ *  rather than a crash. */
 const WEB_SEARCH_PAID = process.env.OPENZOO_XBOT_WEB_PAID === '1';
+void WEB_SEARCH_PAID;
 
 /** How many mentions are answered at once. */
 const CONCURRENCY = Number(process.env.OPENZOO_XBOT_CONCURRENCY || 18);
@@ -170,13 +194,69 @@ export function hasFreeQuestion(state, authorId) {
  * archive is attached); without it, a small placeholder is created so the bot
  * still has somewhere to accumulate.
  */
+/**
+ * THE AUTHORITATIVE FACTS, READ FROM THE LIVE SYSTEM AT BIND TIME.
+ *
+ * `needsArchive()` attaches the shared context for any openzoo question — but
+ * that context was seeded ONLY with threads the bot had read, so it knew what
+ * people had ASKED and nothing about what openzoo actually is. Questions like
+ * "how do I set up multi-user accounts" or "is openzoo a scam" get no web
+ * search (correctly — the open web does not know) and then had nothing to
+ * recall either, so the model answered from its priors.
+ *
+ * Everything below is FETCHED, not typed: the rails and terms come out of a
+ * real 402, the catalog size and prices out of /v1/models. A hand-written fact
+ * sheet goes stale silently; this one cannot say we support a rail we stopped
+ * offering.
+ */
+async function openzooFacts() {
+  const lines = ['OPENZOO — AUTHORITATIVE FACTS (fetched live from the gateway).'];
+  try {
+    const r = await fetch(`${GATEWAY}/v1/chat/completions`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ model: 'openai/gpt-4o-mini', max_tokens: 1, messages: [{ role: 'user', content: 'hi' }] }),
+    });
+    const j = await r.json().catch(() => ({}));
+    const rows = j.accepts || [];
+    if (rows.length) {
+      lines.push(`PAYMENT RAILS (${rows.length}), from a live 402:`);
+      for (const a of rows) {
+        const x = a.extra || {};
+        lines.push(`  - ${x.symbol} on ${a.network} (decimals ${x.decimals})`);
+      }
+    }
+    if (j.terms) lines.push(`TERMS: settlement ${j.terms.settlement}; refunds ${j.terms.refunds}`);
+    if (j.help) lines.push(`HELP TEXT SHOWN TO PAYERS: ${j.help}`);
+  } catch { /* facts are best-effort; the bot must still boot */ }
+  try {
+    const r = await fetch(`${GATEWAY}/v1/models`);
+    const { data } = await r.json();
+    lines.push(`CATALOG: ${(data || []).length} models served.`);
+    for (const id of ['x-ai/grok-4.6', 'anthropic/claude-fable-5', 'deepseek/deepseek-v4-pro-0813']) {
+      const m = (data || []).find((x) => x.id === id);
+      if (m?.pricing) lines.push(`  - ${id}: prompt ${m.pricing.prompt}/tok, completion ${m.pricing.completion}/tok`);
+    }
+  } catch { /* ditto */ }
+  lines.push(
+    'TENANCY: there are no openzoo accounts and no openzoo API keys. A platform keeps ONE funded wallet',
+    'and gives each of its users a SIGNED NAMESPACE; the gateway derives the tenant as',
+    'sha256(chain:signer:namespace), so one wallet runs many fully isolated memories. The signer is in',
+    'the hash, so nobody can squat a namespace label they do not control.',
+    'PRICING: billed = 3x our calibrated real cost, capped so it never exceeds buying the same call',
+    'direct from OpenRouter. leCore forwards fewer tokens, which is where the saving comes from.',
+  );
+  return lines.join('\n');
+}
+
 export async function ensureSharedContext(state) {
   if (process.env.OPENZOO_XBOT_CONTEXT) return process.env.OPENZOO_XBOT_CONTEXT;
   if (state?.contextId) return state.contextId;
+  const facts = await openzooFacts();
   const res = await fetch(`${GATEWAY}/v1/hrr/bind`, {
     method: 'POST',
     headers: { 'content-type': 'application/json' },
-    body: JSON.stringify({ corpus: 'openzoobot shared corpus. Threads the bot reads are appended here.' }),
+    body: JSON.stringify({ corpus: `openzoobot shared corpus. Threads the bot reads are appended here.\n\n${facts}` }),
   });
   if (!res.ok) throw new Error(`bind ${res.status}: ${(await res.text()).slice(0, 160)}`);
   const j = await res.json();
@@ -231,6 +311,16 @@ export function usd(n) {
  * smaller font. The saving shows up on its own when a long thread is bound.
  */
 export function priceLine({ routedModel, billedUsd, directUsd }) {
+  // "ladder · $0" READS AS A MODEL NAMED LADDER.
+  //
+  // When the answer ladder serves from memory the gateway reports model
+  // "ladder" and bills nothing — which is the best receipt the product can
+  // print, and it rendered as though we had routed to some obscure model for
+  // free. Say what actually happened instead; there is no direct comparison to
+  // make because no model ran.
+  if (String(routedModel) === 'ladder' || (billedUsd === 0 && String(routedModel).includes('ladder'))) {
+    return ['answered from memory — no model call, $0', SITE].join(' · ');
+  }
   const bits = [short(routedModel), usd(billedUsd)];
   if (directUsd > 0 && billedUsd > 0) {
     const x = directUsd / billedUsd;
@@ -267,6 +357,18 @@ function short(id) {
  * answer from its own knowledge — and is told to decline rather than guess.
  */
 const SYSTEM_PROMPT = [
+  // THERE IS NO SECOND TURN. Whatever comes back is posted; the model gets no
+  // chance to follow up on a promise, and cannot browse unless
+  // OPENZOO_XBOT_WEB=1. Told plainly, because it announced a lookup it could
+  // not perform and that announcement was published verbatim.
+  'You get exactly ONE turn and your reply is posted immediately to X. You cannot',
+  'browse, open links, or check a page later. Never say you will check, look up,',
+  'verify or come back — answer NOW from the thread and what you already know. If',
+  'you genuinely cannot answer, say what you do know and what is missing, in one',
+  'sentence. Never promise future work.',
+  // Belt and braces with stripModelReceipt(): the pattern is in its context now.
+  'NEVER write a price, cost, or "Nx cheaper" line. A receipt is appended to your',
+  'reply automatically with the real settled figures. Any price you write is invented.',
   'You are @openzoobot on X, run by openzoo (openzoo.fun).',
   '',
   'Facts you must not contradict:',
@@ -613,8 +715,160 @@ export async function bindThread(contextId, chain, mention) {
   }
 }
 
-export async function askZoo(question, { key, maxTokens = ANSWER_TOKENS, thread = '', contextId = '' } = {}) {
-  const res = await fetch(`${GATEWAY}/v1/chat/completions`, {
+/**
+ * SEARCH OURSELVES, THEN INJECT — DO NOT HAND THE MODEL A TOOL.
+ *
+ * OpenRouter's `web` plugin worked but cost REAL money: MEASURED $0.07536 on a
+ * single grok-4.6 answer, ~20x a plain reply, and on the free lane that is the
+ * operator's wallet. Worse, grok has native tool-calling and would sometimes
+ * write `{"name":"web_search","arguments":{...}}` into `content` instead of
+ * using the injected results — published live 2026-08-26.
+ *
+ * Brave's API is a plain GET on a plan that is already paid (50 rps, unlimited
+ * monthly). Searching here and pasting the results into the prompt gives the
+ * same grounding at no marginal cost, AND removes the failure mode by
+ * construction: a model offered no tool cannot emit a tool call.
+ *
+ * Never throws. Search is an enhancement; if Brave is down the model answers
+ * from the thread as it did before.
+ */
+const BRAVE_KEY_FILE = process.env.BRAVE_KEY_FILE
+  || path.join(os.homedir(), '.brave_key');
+const BRAVE_RESULTS = Number(process.env.OPENZOO_XBOT_BRAVE_RESULTS || 5);
+/** How far back a startup backfill will reach. 0 = no limit (answer everything
+ *  X still holds). Default 48h: catches a real outage, not launch week. */
+const BACKFILL_MAX_AGE_H = Number(process.env.OPENZOO_XBOT_BACKFILL_MAX_AGE_H || 48);
+
+function braveKey() {
+  if (process.env.BRAVE_API_KEY) return process.env.BRAVE_API_KEY.trim();
+  try { return fs.readFileSync(BRAVE_KEY_FILE, 'utf8').trim(); } catch { return ''; }
+}
+
+/**
+ * Web grounding as a prompt block, or '' when unavailable.
+ *
+ * TWO CALLS, because the Pro AI plan gives a SYNTHESIZED answer and raw links
+ * are a poor substitute. /web/search?summary=1 returns a summarizer key;
+ * /summarizer/search redeems it for prose that already reconciles the sources.
+ * VERIFIED: "grok-4.6 openrouter price per million tokens" came back with the
+ * $2/$6 rates, the $0.50 cache rate AND the 200k-token doubling — three facts
+ * no single snippet carried.
+ *
+ * Both are returned: the summary so the model has an answer to work from, the
+ * links so it can cite. Search never throws — grounding is an enhancement, and
+ * a Brave outage must not take the bot down.
+ */
+/**
+ * IS THIS A QUESTION SEARCH CAN HELP WITH?
+ *
+ * Searching every mention was wrong twice over: it spends a lookup on "gm" and
+ * "bruh lol", and an irrelevant result set actively DAMAGED an answer (see the
+ * note inside braveSearch). Most mentions are banter, or ask about openzoo
+ * itself — which the system prompt already covers better than the open web.
+ *
+ * Deliberately conservative: when unsure, do NOT search. A skipped search costs
+ * nothing, since the model answers as it always did; a bad one poisons the
+ * prompt.
+ */
+const LOOKUP_RE = /\b(search|look ?up|google|find out|check online|check the web|browse|look online|what.s new|price|pricing|cost|costs|rate|rates|per million|how much|latest|current|today|recent|news|released?|announced?|when did|who is|what is the|docs?|documentation|endpoint|version|benchmark|compared?|vs\.?)\b/i;
+
+/** An explicit instruction to search wins over every heuristic, including the
+ *  length floor — "google X" is four words and unambiguous. */
+const EXPLICIT_SEARCH_RE = /\b(search|look ?up|google|check online|check the web|look online|browse)\b/i;
+
+export function wantsSearch(question) {
+  const q = String(question || '').trim();
+  if (EXPLICIT_SEARCH_RE.test(q)) return true;
+  if (q.length < 12) return false;
+  return LOOKUP_RE.test(q);
+}
+
+export async function braveSearch(query, { count = BRAVE_RESULTS } = {}) {
+  const key = braveKey();
+  const q = String(query || '').trim();
+  if (!key || !q) return '';
+  const hdr = { accept: 'application/json', 'x-subscription-token': key };
+  try {
+    const u = new URL('https://api.search.brave.com/res/v1/web/search');
+    u.searchParams.set('q', q.slice(0, 380));
+    u.searchParams.set('count', String(count));
+    u.searchParams.set('summary', '1');
+    const res = await fetch(u, { headers: hdr });
+    if (!res.ok) return '';
+    const j = await res.json();
+
+    const rows = ((j.web || {}).results || []).slice(0, count);
+    const links = rows.map((r, i) => {
+      const d = String(r.description || '').replace(/<[^>]*>/g, '').replace(/\s+/g, ' ').trim();
+      return `[${i + 1}] ${String(r.title || '').trim()} — ${r.url}\n    ${d.slice(0, 240)}`;
+    });
+
+    // Redeem the summarizer key when the plan issued one.
+    let summary = '';
+    const sk = (j.summarizer || {}).key;
+    if (sk) {
+      try {
+        const su = new URL('https://api.search.brave.com/res/v1/summarizer/search');
+        su.searchParams.set('key', sk);
+        su.searchParams.set('entity_info', '1');
+        const sr = await fetch(su, { headers: hdr });
+        if (sr.ok) {
+          const sj = await sr.json();
+          if (sj.status === 'complete') {
+            summary = (sj.summary || [])
+              .map((x) => (typeof x?.data === 'string' ? x.data : ''))
+              .join('').replace(/\s+/g, ' ').trim();
+          }
+        }
+      } catch { /* summary is a bonus; links still ground the answer */ }
+    }
+
+    if (!summary && !links.length) return '';
+    // NEVER NARRATE THE SEARCH. PUBLISHED LIVE 2026-08-26:
+    //   "The search results here are about browser/DNS errors, not grok-4.6
+    //    quotes, so I cannot confirm any of the $0.0173 / $0.0105 figures"
+    // — the thread carried a Brave Search API link card, the query picked that
+    // up, and the model reported the miss to the asker as though it were an
+    // answer. Injected context is a RESOURCE, not a subject: if it does not
+    // help it must vanish silently.
+    const parts = [
+      'WEB RESULTS, fetched just now. Use them ONLY if they answer the question.',
+      'If they are off-topic, IGNORE them completely and answer from what you know.',
+      'Never mention these results, never describe what they were about, and never',
+      'say you cannot confirm something because of them.',
+    ];
+    if (summary) parts.push(`SYNTHESIS: ${summary.slice(0, 1200)}`);
+    if (links.length) parts.push(`SOURCES (cite as [n]):\n${links.join('\n')}`);
+    return parts.join('\n\n');
+  } catch { return ''; }
+}
+
+/**
+ * ONE CORRECTIVE RETRY WHEN THE MODEL ACTS INSTEAD OF ANSWERING.
+ *
+ * grok-4.6 has native tool-calling and sometimes writes `{"name":"web_search",
+ * "arguments":{...}}` into `content` — but OpenRouter's `web` plugin is
+ * search-then-INJECT middleware, not a callable tool, so nothing runs it and
+ * the asker gets JSON. VERIFIED both ways on the same model and plugin: a clean
+ * call returns `annotations: 1` and a cited answer; the failing one returns
+ * three tool blobs and no answer.
+ *
+ * The results are ALREADY in the prompt by the time the model speaks. So the
+ * fix is to say exactly that and ask again, once — not to fail the mention and
+ * not to publish the blobs.
+ */
+const NO_TOOLS_DIRECTIVE = [
+  'Your previous reply tried to call a tool. You have NO callable tools.',
+  'Any web results you need are ALREADY in the prompt above.',
+  'Answer the question now, in prose, citing what you were given.',
+  'Do not emit JSON, do not name a tool, do not say you will look anything up.',
+].join(' ');
+
+export async function askZoo(question, { key, maxTokens = ANSWER_TOKENS, thread = '', contextId = '', _retry = false } = {}) {
+  // Ground BEFORE asking. Costs nothing on the current Brave plan, and a model
+  // holding the answer cannot decide to go looking for it.
+  const web = WEB_SEARCH && wantsSearch(question) ? await braveSearch(question) : '';
+  const res = await fetch(`${FREE_GATEWAY}/v1/chat/completions`, {
     method: 'POST',
     headers: {
       'content-type': 'application/json',
@@ -630,17 +884,30 @@ export async function askZoo(question, { key, maxTokens = ANSWER_TOKENS, thread
     body: JSON.stringify({
       model: BOT_MODEL,
       max_tokens: maxTokens,
-      ...(WEB_SEARCH ? { plugins: [{ id: 'web' }] } : {}),
+      // NO `plugins` ARRAY. OpenRouter's web plugin cost $0.07536 on a measured
+      // grok-4.6 answer AND handed the model a tool it would sometimes call in
+      // text instead of using. We search first (Brave, already-paid plan) and
+      // paste the result in, so the model is never offered a tool at all.
       messages: [
-        { role: 'system', content: SYSTEM_PROMPT },
-        { role: 'user', content: thread ? `${thread}\n\n${question}` : question },
+        { role: 'system', content: _retry ? `${SYSTEM_PROMPT}\n\n${NO_TOOLS_DIRECTIVE}` : SYSTEM_PROMPT },
+        { role: 'user', content: [web, thread, question].filter(Boolean).join('\n\n') },
       ],
     }),
   });
   const json = await res.json().catch(() => ({}));
   if (!res.ok) throw new Error(`gateway ${res.status}: ${JSON.stringify(json).slice(0, 200)}`);
 
-  return shapeResult(json);
+  const shaped = await shapeResult(json);
+  // Retry ONCE. A second failure means the model will not answer this question,
+  // and paying a third time to hear the same thing helps nobody.
+  if (!_retry) {
+    const { stripped } = stripToolCalls(shaped.answer);
+    if (stripped || isAnnouncement(shaped.answer)) {
+      console.error('   model emitted a tool call / announcement — re-asking once with the no-tools directive');
+      return askZoo(question, { key, maxTokens, thread, contextId, _retry: true });
+    }
+  }
+  return shaped;
 }
 
 /**
@@ -654,7 +921,6 @@ export async function shapeResult(json) {
   const usage = json.usage || {};
   const x402 = json.x402 || {};
   const routedModel = json.model || 'unknown';
-  const billedUsd = Number(x402.billedUsd ?? usage.billedUsd ?? usage.cost ?? 0);
 
   // TRUST THE GATEWAY'S FIGURES. An earlier version recomputed cost here from
   // usage.prompt_tokens x catalog rate, to dodge quotes priced on reserved
@@ -669,9 +935,24 @@ export async function shapeResult(json) {
   return {
     answer,
     routedModel,
+    // WHICH FIELD IS WHICH, because three of them are dollar amounts for the
+    // same call and picking the wrong one is invisible until someone checks:
+    //   billedUsd  what the caller was CHARGED, after reconciliation  <- the price
+    //   quotedUsd  the pre-flight quote, before refunding down
+    //   directUsd  what these tokens on this model cost buying direct
+    //   actualUsd  what the upstream really charged US (metered, not estimated)
+    // The receipt must lead with billedUsd. Leading with directUsd prints the
+    // price the asker did NOT pay and reads as "same as OpenRouter" on a call
+    // that was cheaper than OpenRouter.
     billedUsd: Number(x402.billedUsd ?? usage.cost ?? 0),
     directUsd: Number(x402.directUsd ?? 0),
-    reservedUsd: Number(x402.billedUsd ?? 0),
+    // `reservedUsd` was set to billedUsd — the same number under a name meaning
+    // the opposite, and nothing read it. It is the QUOTE; the gap between it
+    // and billedUsd is the reconciliation refund.
+    quotedUsd: Number(x402.quotedUsd ?? x402.billedUsd ?? 0),
+    /** OpenRouter's metered cost to US. Never shown to an asker — it is our
+     *  margin — but carried so the operator log can print a true number. */
+    actualUsd: Number(x402.actualUsd ?? 0),
     promptTokens: Number(usage.prompt_tokens || 0),
     completionTokens: Number(usage.completion_tokens || 0),
   };
@@ -760,13 +1041,18 @@ export async function askZooPaid(question, { burner, thread = '', maxTokens = AN
   // chat(), not fetch(): fetch returns { response, paid, receipt }, so calling
   // .json() on it throws "res.json is not a function" — which the underfunded
   // classifier then reads as a real fault and never sends the funding reply.
+  // SAME GROUNDING AS THE FREE LANE. This was gated behind WEB_SEARCH_PAID
+  // because OpenRouter's plugin cost $0.075 a call and that came out of the
+  // ASKER's wallet. Brave costs nothing marginal, so there is no longer a
+  // reason to give a paying user a worse-informed answer than a free one —
+  // which is precisely backwards.
+  const web = WEB_SEARCH && wantsSearch(question) ? await braveSearch(question) : '';
   const { data } = await pay.chat({
     model: BOT_MODEL,
     max_tokens: maxTokens,
-    ...(WEB_SEARCH && WEB_SEARCH_PAID ? { plugins: [{ id: 'web' }] } : {}),
     messages: [
       { role: 'system', content: SYSTEM_PROMPT },
-      { role: 'user', content: thread ? `${thread}\n\n${question}` : question },
+      { role: 'user', content: [web, thread, question].filter(Boolean).join('\n\n') },
     ],
   // Same shared context as the free lane — a paid asker should recall
   // everything the bot has read, not start from an empty corpus.
@@ -792,6 +1078,98 @@ export async function askZooPaid(question, { burner, thread = '', maxTokens = AN
  */
 const SHILL = /\b(launch(ing)?|airdrop|presale|stealth|just dropped)\b[\s\S]*\$[A-Z]{2,10}\b|\$[A-Z]{2,10}\b[\s\S]*\b(ape|wagmi|moon|100x|don'?t regret|stay poor)\b|ape or stay poor|\u{1F680}/iu;
 
+/**
+ * AN ANNOUNCEMENT IS NOT AN ANSWER, AND MUST NEVER BE PUBLISHED.
+ *
+ * The bot has no browsing unless OPENZOO_XBOT_WEB=1, but the model does not
+ * know that and will happily promise to go and look. PUBLISHED LIVE
+ * 2026-08-26, in reply to a direct pricing question:
+ *   "I'll check openzoo's live pricing page and how it quotes vs OpenRouter
+ *    before answering the 1.4x claim. Grokking the footer numbers against the
+ *    site, not the thread."
+ * — and then nothing, because there is no second turn. The asker got a promise
+ * and we paid for a generation that answered nothing.
+ *
+ * Same failure the answer ladder hit with `worthTeaching()`: a hedge that looks
+ * like prose passes every length and format check. Detect the SHAPE — first
+ * person, future tense, about retrieving — not any particular wording.
+ */
+const ANNOUNCEMENT_RE = new RegExp([
+  "^\\s*(?:i(?:'ll| will| am going to| shall)|let me|lemme|going to|about to|one (?:sec|moment)|hold on|checking|looking (?:in)?to)\\b",
+  "\\b(?:i(?:'ll| will)|let me)\\s+(?:go\\s+)?(?:check|look|verify|confirm|fetch|pull|read|grab|review|dig|investigate|research)\\b",
+].join("|"), "i");
+
+/**
+ * MODELS EMIT TOOL CALLS AS TEXT, AND WE PUBLISHED THEM.
+ *
+ * PUBLISHED LIVE 2026-08-26 with OPENZOO_XBOT_WEB=1:
+ *   I'll pull openzoo's live pricing page ... {"name": "web_search",
+ *   "arguments": {"query": "openzoo.fun grok-4.6 pricing vs OpenRouter",
+ *   "num_results": 8}}{"name": "web_search", "arguments": {...}}
+ * OpenRouter's `web` plugin is search-then-INJECT middleware, not a callable
+ * tool, so grok-4.6 wrote the call syntax into `content` and nothing ever ran
+ * it. The asker got a promise followed by three JSON blobs.
+ *
+ * It also defeated isAnnouncement(): the blobs padded the reply past the
+ * 400-char "it actually answered" threshold. So strip them FIRST, then judge
+ * what is left — which for that post was just the promise.
+ */
+const TOOLCALL_RE = /\{\s*"(?:name|tool_name|function)"\s*:\s*"[^"]+"\s*,\s*"(?:arguments|parameters|args)"\s*:\s*\{[\s\S]*?\}\s*\}/g;
+
+/** Remove inline tool-call JSON. Returns { text, stripped }. */
+export function stripToolCalls(answer) {
+  const raw = String(answer || '');
+  const text = raw.replace(TOOLCALL_RE, ' ').replace(/[ \t]{2,}/g, ' ').trim();
+  return { text, stripped: text.length !== raw.trim().length };
+}
+
+/** true when `answer` promises work instead of doing it. */
+export function isAnnouncement(answer) {
+  // Judge the PROSE, not the machinery the model leaked into it.
+  const t = stripToolCalls(answer).text;
+  if (!t) return true;
+  if (!ANNOUNCEMENT_RE.test(t)) return false;
+  // A long reply that OPENS with "I'll check" but then actually answers is
+  // fine — the failure is a reply that is ONLY the promise. Short + promise.
+  return t.length < 400;
+}
+
+export class AnnouncementError extends Error {
+  constructor(answer) {
+    super(`model announced instead of answering: ${String(answer || '').slice(0, 120)}`);
+    this.name = 'AnnouncementError';
+    this.announced = answer;
+  }
+}
+
+/**
+ * THE MODEL WRITES ITS OWN RECEIPT, AND IT IS ALWAYS WRONG.
+ *
+ * PUBLISHED LIVE 2026-08-26 — one reply carried TWO price lines that disagreed:
+ *   ...Scoped @openzoo packages... grok-4.6 · $0.0094 · vs $0.0261 direct on
+ *   OpenRouter — 2.8× cheaper · openzoo.fun          <- invented by the model
+ *   grok-4.6 · $0.0204 · same as OpenRouter direct   <- the real one, appended
+ *
+ * Why it started: past replies (receipt and all) are bound into the shared
+ * context and quoted in threads, so the format is now something the model has
+ * SEEN and imitates — with numbers it cannot possibly know, since the price is
+ * settled after it finishes speaking.
+ *
+ * Only priceLine() may state a price. Strip anything receipt-shaped the model
+ * emits, wherever it lands: the format is distinctive enough to match on.
+ */
+// The model id CONTAINS a dot (grok-4.6), so a [^.]*? lead-in stops inside it
+// and leaves 'grok-4.' stranded in the reply. Match the id explicitly.
+const MODEL_RECEIPT_RE = /[A-Za-z0-9._\/-]+\s*·\s*\$\d[\d.,]*\s*·[^\n]*?(?:openzoo\.fun|direct on OpenRouter|never more)[^\n]*/gi;
+
+export function stripModelReceipt(answer) {
+  return String(answer || '')
+    .replace(MODEL_RECEIPT_RE, ' ')
+    .replace(/[ \t]{2,}/g, ' ')
+    .replace(/\s+([.,!?])/g, '$1')
+    .trim();
+}
+
 export function refuseShill(answer) {
   if (!SHILL.test(String(answer || ''))) return answer;
   return "I don't announce or promote token launches — not mine to do. openzoo.fun is the only project I speak for.";
@@ -822,7 +1200,16 @@ export function composeReply(result, { limit = TWEET_LIMIT } = {}) {
   const room = limit - receipt.length - 2; // "\n\n" between answer and receipt
   // Strip any self-tag the model wrote: '@openzoobot' in our OWN reply is a
   // self-mention, and a self-mention is the seed of the paid loop above.
-  let answer = groupAddresses(refuseShill(result.answer)).replace(/@openzoobot/gi, 'openzoobot').replace(/\s+/g, ' ').trim();
+  // A PROMISE IS NOT A REPLY. There is no second turn on X — whatever this
+  // returns is what the asker gets, forever. See isAnnouncement().
+  const { text: cleaned, stripped } = stripToolCalls(result.answer);
+  // Tool-call JSON in a reply means the model tried to act and could not. Even
+  // if prose survives, it was written EXPECTING tool results that never came —
+  // so it is a half-answer, not an answer.
+  if (stripped) throw new AnnouncementError(result.answer);
+  if (isAnnouncement(cleaned)) throw new AnnouncementError(result.answer);
+  result = { ...result, answer: cleaned };
+  let answer = groupAddresses(refuseShill(stripModelReceipt(result.answer))).replace(/@openzoobot/gi, 'openzoobot').replace(/\s+/g, ' ').trim();
   if (answer.length > room) answer = answer.slice(0, Math.max(0, room - 1)).trimEnd() + '…';
   return `${answer}\n\n${receipt}`;
 }
@@ -1007,6 +1394,35 @@ export function loadCreds(env = process.env) {
     oauth2RefreshToken: env.X_OAUTH2_REFRESH_TOKEN,
     subscriptionKey: env.OPENZOO_SUBSCRIPTION_KEY,
   };
+  // X CREDENTIALS FROM A FILE, like every other secret this shim reads.
+  //
+  // These were env-only, so running the bot meant pasting five secrets onto a
+  // command line every time — where they land in shell history and are visible
+  // to any other process via `ps`. Everything else here (wallet.json,
+  // subscription.json) loads from ~/.openzoo; this now does too.
+  //
+  // Env still WINS when set, so an existing invocation or a CI runner is
+  // unaffected. Point OPENZOO_X_ENV at any dotenv-shaped file to override.
+  if (!c.apiKey || !c.accessToken || !c.bearer) {
+    try {
+      const f = env.OPENZOO_X_ENV || path.join(os.homedir(), '.openzoo', 'x.env');
+      for (const line of fs.readFileSync(f, 'utf8').split('\n')) {
+        const m = line.match(/^\s*([A-Z_0-9]+)\s*=\s*(.*)$/);
+        if (!m) continue;
+        const v = m[2].trim().replace(/^["']|["']$/g, '');
+        if (!v) continue;
+        switch (m[1]) {
+          case 'X_API_KEY': c.apiKey ||= v; break;
+          case 'X_API_SECRET': c.apiSecret ||= v; break;
+          case 'X_ACCESS_TOKEN': c.accessToken ||= v; break;
+          case 'X_ACCESS_SECRET': c.accessSecret ||= v; break;
+          case 'X_BEARER_TOKEN': c.bearer ||= v; break;
+          case 'X_BOT_USER_ID': c.botUserId ||= v; break;
+          default: break;
+        }
+      }
+    } catch { /* no file is fine — env or the missing-creds report covers it */ }
+  }
   if (!c.subscriptionKey) {
     try {
       const f = path.join(os.homedir(), '.openzoo', 'subscription.json');
@@ -1032,6 +1448,77 @@ export function missingCreds(c) {
   return need;
 }
 
+/**
+ * ANSWER WHAT WAS MISSED WHILE THE BOT WAS DOWN.
+ *
+ * `sinceId` only ever moves FORWARD, so every mention that arrived while the
+ * process was off is invisible the moment the cursor passes it — the bot comes
+ * back, fetches from the newest id it saw, and those people are never answered.
+ * Nothing in the loop looks backwards, and the orphan sweep only rescues
+ * mentions this process itself claimed.
+ *
+ * So on startup, page BACKWARDS through what X still holds (~800 mentions) and
+ * rewind the cursor to just before the oldest one that has no entry in
+ * `answered`. The normal fetch then re-sees exactly those, and the `answered`
+ * map skips everything already handled — which is why this is safe to run every
+ * boot and cannot double-post.
+ *
+ * Bounded by PAGES so a long outage cannot turn one restart into a hundred
+ * replies; the rest stay unanswered rather than flooding a timeline.
+ */
+export async function backfillUnanswered({ bearer, botUserId, state, pages = 4, maxAgeHours = BACKFILL_MAX_AGE_H, persist = true }) {
+  const answered = state.answered || {};
+  // AGE CAP, because "everything unanswered" and "everything worth answering"
+  // are not the same set. MEASURED on the first run: 23 unanswered mentions,
+  // ALL from five days earlier — the launch-day burst, including the same
+  // question repeated five times in one thread and several bare "Gm"s.
+  // Replying to all of that at once reads as a malfunction, not a catch-up.
+  // The real case this serves is a bot that was down for an hour.
+  const cutoff = maxAgeHours > 0 ? Date.now() - maxAgeHours * 3600_000 : 0;
+  let token = '';
+  let oldestUnanswered = null;
+  let scanned = 0;
+  let tooOld = 0;
+  for (let i = 0; i < pages; i++) {
+    const u = new URL(`https://api.x.com/2/users/${botUserId}/mentions`);
+    u.searchParams.set('max_results', '100');
+    u.searchParams.set('tweet.fields', 'created_at');
+    if (token) u.searchParams.set('pagination_token', token);
+    let j;
+    try {
+      const res = await fetch(u, { headers: { authorization: `Bearer ${bearer}` } });
+      if (!res.ok) break;
+      j = await res.json();
+    } catch { break; }
+    const rows = j.data || [];
+    if (!rows.length) break;
+    scanned += rows.length;
+    for (const t of rows) {
+      if (answered[t.id]) continue;
+      if (cutoff && t.created_at && Date.parse(t.created_at) < cutoff) { tooOld += 1; continue; }
+      const id = BigInt(t.id);
+      if (oldestUnanswered === null || id < oldestUnanswered) oldestUnanswered = id;
+    }
+    token = j.meta?.next_token || '';
+    if (!token) break;
+  }
+  if (oldestUnanswered === null) return { scanned, tooOld, rewound: 0 };
+  // Rewind ONLY backwards. A cursor that moved forward is doing its job.
+  if (state.sinceId && BigInt(state.sinceId) < oldestUnanswered) return { scanned, tooOld, rewound: 0 };
+  const before = state.sinceId;
+  state.sinceId = String(oldestUnanswered - 1n);
+  // CALLER DECIDES WHETHER THIS IS PERSISTED.
+  //
+  // This used to saveState() itself, which made the function impossible to
+  // probe: passing a deep COPY of the state still wrote the copy's rewound
+  // cursor straight to ~/.openzoo/xbot.json, because saveState persists
+  // whatever object it is handed. I did exactly that while "dry-running" it and
+  // rewound the live cursor five days, which would have replayed 23 old
+  // mentions on the next tick.
+  if (persist) saveState(state);
+  return { scanned, tooOld, rewound: 1, from: before, to: state.sinceId };
+}
+
 export async function fetchMentions({ bearer, botUserId, sinceId }) {
   const u = new URL(`https://api.x.com/2/users/${botUserId}/mentions`);
   u.searchParams.set('max_results', '25');
@@ -1220,12 +1707,49 @@ export function questionFrom(text) {
  * posted, so "did it actually reply?" could only be answered by opening X —
  * and a --dry-run run looked identical to a live one.
  */
+/**
+ * A FAILED POST MUST NOT RE-BUY THE ANSWER.
+ *
+ * `releaseOrFail` un-claims the mention (`delete state.answered[id]`) so the
+ * next tick can retry — but the next tick re-enters the WHOLE pipeline: refetch
+ * the thread, re-ask the model, re-settle x402, re-render the receipt. So one
+ * `post 401` cost a second paid generation, and the two generations do not
+ * price the same.
+ *
+ * OBSERVED live 2026-08-26: attempt 1 logged `$0.0148 (direct $0.0173)`; the
+ * reply that eventually posted carried `$0.0173 · same as OpenRouter direct` —
+ * attempt 2's numbers. The published receipt did not match any logged call, and
+ * the asker was quoted a price that made the gateway look no cheaper than
+ * buying direct on a call that WAS cheaper.
+ *
+ * So the rendered text is parked against the mention id the moment it exists.
+ * A retry re-posts the identical bytes; only a successful post clears it.
+ */
+function draftKey(state) { state.drafts = state.drafts || {}; return state.drafts; }
+
 async function postAndLog({ creds, text, inReplyTo, state, dryRun, tag, conversationId }) {
   if (dryRun) {
     console.error(`   [dry-run] would reply to ${inReplyTo} (${tag})`);
     return null;
   }
+  if (state && inReplyTo) {
+    const drafts = draftKey(state);
+    // Re-post what was already generated and paid for, if anything.
+    if (drafts[inReplyTo]?.text) {
+      if (drafts[inReplyTo].text !== text) {
+        console.error(`   reusing the first generation's reply (a retry re-asked and would have published different numbers)`);
+      }
+      text = drafts[inReplyTo].text;
+    } else {
+      drafts[inReplyTo] = { text, at: new Date().toISOString() };
+    }
+  }
+  else {
+    console.log(`   posting reply to ${inReplyTo} (${tag})`);
+  }
   const data = await postReply({ creds, text, inReplyTo, state });
+  // Only a landed post clears the draft — a throw above leaves it parked.
+  if (data?.id && state?.drafts) delete state.drafts[inReplyTo];
   if (data?.id) console.error(`   posted https://x.com/i/web/status/${data.id}`);
   // Remember the conversation: from now on, auto-prefixed tags in this thread
   // are noise, not summons (see isAddressedToBot).
@@ -1302,6 +1826,13 @@ export async function runXBot({ once = false, intervalMs = 60_000, dryRun = fals
     saveState(state);
     console.error(`  requeued ${orphans.length} mention(s) stranded by a previous shutdown`);
   }
+  // Mentions missed while the process was DOWN — see backfillUnanswered().
+  try {
+    const bf = await backfillUnanswered({ bearer: creds.bearer, botUserId: creds.botUserId, state, persist: true });
+    const aged = bf.tooOld ? ` (${bf.tooOld} older than ${BACKFILL_MAX_AGE_H}h, skipped — raise OPENZOO_XBOT_BACKFILL_MAX_AGE_H=0 to include them)` : '';
+    if (bf.rewound) console.error(`  backfill: scanned ${bf.scanned}, rewound ${bf.from} -> ${bf.to} to answer missed mentions${aged}`);
+    else console.error(`  backfill: scanned ${bf.scanned}, nothing unanswered${aged}`);
+  } catch { /* backfill is best-effort; never block startup */ }
   const backfilled = await backfillConversations(creds, state).catch(() => 0);
   if (backfilled) console.error(`  participation backfilled: ${backfilled} conversation(s) from own timeline`);
   let sharedCtx = '';
@@ -1313,7 +1844,10 @@ export async function runXBot({ once = false, intervalMs = 60_000, dryRun = fals
     console.error(`  shared context unavailable (${e.message}) — answering without memory`);
   }
   console.error(`openzoo xbot: model=${BOT_MODEL} sinceId=${state.sinceId || '(none)'}`);
-  console.error(`  billing: ${creds.subscriptionKey ? 'subscription key' : 'x402 per call'}`);
+  // NAME BOTH LANES. One line saying "subscription key" was actively
+  // misleading once subs were killed: it reported a lane that answers 402.
+  console.error(`  free lane: ${FREE_GATEWAY} (operator pays x402)`);
+  console.error(`  paid lane: ${GATEWAY} (asker's burner pays x402)`);
   console.error(`  context: ${sharedCtx || '(none — no memory)'}`);
 
   const tick = async () => {
@@ -1461,7 +1995,12 @@ export async function runXBot({ once = false, intervalMs = 60_000, dryRun = fals
             } else throw e;
           }
           const text = composeReply(result);
-          console.error(`  ${t.id} @${t.author_id}: PAID ${burner.address.slice(0, 8)}… ${result.routedModel} ${usd(result.billedUsd)}`);
+          // Print the SAME comparison the free lane does. This showed billed
+          // alone, so a paid answer gave no way to see whether the asker beat
+          // buying direct — the one thing the receipt exists to demonstrate.
+          console.error(`  ${t.id} @${t.author_id}: PAID ${burner.address.slice(0, 8)}… ${result.routedModel} ${usd(result.billedUsd)}`
+            + (result.directUsd > 0 ? ` (direct ${usd(result.directUsd)})` : '')
+            + (result.actualUsd > 0 ? ` [cost ${usd(result.actualUsd)}]` : ''));
           await postAndLog({ creds, text, inReplyTo: t.id, state, dryRun, tag: 'paid', conversationId: t.conversation_id });
           state.answered[t.id] = 'paid';
         } catch (e) {