openzoo 0.48.55 → 0.48.57

package/lib/brief.js

@@ -54,8 +54,21 @@ export function injectBrief(body, selfUrl = null) {
   if (msgs.some((m) => typeof m?.content === 'string' && m.content.includes('connected through an openzoo proxy'))) return null;
 
   const brief = { role: 'system', content: briefFor(selfUrl) };
-  const lastSystem = msgs.reduce((acc, m, i) => (m?.role === 'system' ? i : acc), -1);
+  // THE LEADING SYSTEM RUN ONLY — NOT THE LAST SYSTEM ANYWHERE.
+  //
+  // This used to reduce over the WHOLE array for the last `role === 'system'`,
+  // which is the same thing only while every system message sits at the front.
+  // The moment anything injects one later, the brief is spliced in AFTER the
+  // user's turn, and the conversation the model receives ends with operator
+  // notes instead of a question.
+  //
+  // OBSERVED live: forwarded tail `s a t a t a u s a u s s` — two system
+  // messages after the last user message. The agent replied "I don't see an
+  // explicit question or task for this turn", answered the PREVIOUS turn, and
+  // read as one message behind for an entire session.
+  let lead = -1;
+  while (lead + 1 < msgs.length && msgs[lead + 1]?.role === 'system') lead += 1;
   const out = [...msgs];
-  out.splice(lastSystem + 1, 0, brief); // after any leading system block, before the user turns
+  out.splice(lead + 1, 0, brief); // after the leading system block, before any turn
   return { ...body, messages: out };
 }

package/lib/proxy.js

@@ -406,7 +406,12 @@ async function spillTranscript(body, log, req) {
   // saving — a bigger tail is a bigger `sent` — and that is the correct trade:
   // measured 8.13x on the fleet leaves room to spend some of it on an agent
   // that remembers its own last few moves.
-  const minTurns = Number(process.env.OPENZOO_TAIL_MIN_TURNS || 12);
+  // 12 was set while the model was ALSO missing its own last turn to a brief
+  // spliced in behind it (fixed in 0.48.56), so part of that floor was paying
+  // for a bug rather than for coherence. 6 turns still covers "what did I just
+  // do" — the case retrieval cannot answer, because the model does not know to
+  // query for it — and hands the rest back as saving.
+  const minTurns = Number(process.env.OPENZOO_TAIL_MIN_TURNS || 6);
   if (msgs.length - cut < minTurns) {
     for (let i = Math.max(firstSpillable + 1, msgs.length - minTurns); i > firstSpillable; i--) {
       if (severable(i)) { cut = i; break; }
@@ -510,6 +515,13 @@ async function spillTranscript(body, log, req) {
   // 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`);
@@ -527,12 +539,18 @@ async function spillTranscript(body, log, req) {
   // 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 || 6000),
-    Math.max(Number(process.env.OPENZOO_RECALL_MIN_TOKENS || 1500),
-             Math.round(askChars / 2)),
+    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(32, Math.round(budget / 320)));
+  const topK = Math.max(4, Math.min(12, Math.round(budget / 320)));
 
   return {
     body: Buffer.from(JSON.stringify({ ...body, messages: [...head, ...msgs.slice(cut)] })),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openzoo",
-  "version": "0.48.55",
+  "version": "0.48.57",
   "description": "Local x402-paying proxy + MCP server for openzoo.fun — point any OpenAI-compatible harness (Cursor, Claude Code, aider, SDKs) at localhost and it pays per call from a local burner wallet. Solana and Base rails live; Robinhood experimental.",
   "license": "MIT",
   "type": "module",