openzoo 0.48.15 → 0.48.17

package/lib/grokui.mjs

@@ -359,7 +359,16 @@ function newGroupThread(names) {
 // sidecar appends to the same bound context instead of starting fresh.
 const BIND_CHUNK_BYTES = 512 * 1024;
 // Chained auto-run commands per user message. Each hop is a paid call.
-const AUTO_MAX_STEPS = Number(process.env.OZ_AUTO_MAX_STEPS || 8);
+// 8 was far too tight. A real task — install a toolchain, read a tree, wire a
+// service — is dozens of directives, so auto kept halting mid-job and telling
+// the user to type "continue", which is the exact thing auto exists to avoid.
+// Still bounded, because every hop is a paid call, but bounded at a number
+// that lets a job finish.
+const AUTO_MAX_STEPS = Number(process.env.OZ_AUTO_MAX_STEPS || 60);
+// An empty completion is a provider hiccup, not an answer. In auto we retry it
+// silently rather than parking the thread behind a "say continue" note the
+// user then has to answer — that turned a transient blip into a manual step.
+const AUTO_EMPTY_RETRIES = Number(process.env.OZ_AUTO_EMPTY_RETRIES || 3);
 // Ceiling on subagents per thread. Spawning is fire-and-forget and each child
 // can spawn too, so without a count it is unbounded — MEASURED as 15+ threads
 // all named tetris-contract, every one of them a live agent making paid calls.
@@ -516,7 +525,7 @@ function execCommand(command, cwd) {
     exec(command, { cwd, shell: RUN_SHELL, timeout: RUN_TIMEOUT_MS, maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
       let out = (stdout || '') + (stderr ? '\n' + stderr : '');
       if (err) out += `\n(exit ${err.code ?? 1})`;
-      resolve(out.slice(0, 6000) || '(no output)');
+      resolve(keepWhole(out) || '(no output)');
     });
   });
 }
@@ -572,6 +581,26 @@ const usd = (n) => (n >= 0.01 || n === 0 ? '$' + n.toFixed(2) : '$' + n.toFixed(
 //
 // So: feed back the head and tail (where the answer nearly always is) and say
 // plainly that the middle is recallable rather than lost.
+// Directive output goes into t.history VERBATIM, because bindThread() binds
+// history — so whatever is cut here is not "elided", it is DESTROYED before
+// the holographic context ever sees it.
+//
+// These used to be hard slices at 4-8k right where the output was produced:
+// a command's stdout, a READ, a FETCH, an MCP tool result. The user saw
+// "…(truncated)" and the rest was simply gone — unrecallable, because it was
+// never stored. That is the opposite of what this product does.
+//
+// So: keep the whole thing (up to a sanity ceiling that exists only to stop a
+// runaway `yes` or a binary dump from bloating the thread store), let it bind,
+// and let condense() decide how much the MODEL sees on the next hop. Big
+// outputs are exactly the case leCore is for.
+const KEEP_MAX = Number(process.env.OZ_KEEP_MAX || 400000);
+function keepWhole(text) {
+  const s = String(text ?? '');
+  if (s.length <= KEEP_MAX) return s;
+  return `${s.slice(0, KEEP_MAX)}\n…[${s.length - KEEP_MAX} chars over the ${KEEP_MAX}-char store ceiling and dropped]`;
+}
+
 const FEEDBACK_MAX = Number(process.env.OZ_FEEDBACK_MAX || 3000);
 function condense(label, text) {
   const s = String(text ?? '');
@@ -908,7 +937,7 @@ async function tryDirective(reply, originId) {
     const rel = readD[1].trim();
     try {
       const data = readFileSync(safeResolveIn(dirFor(originId), rel), 'utf8');
-      return `${rel}:\n${data.slice(0, 4000)}${data.length > 4000 ? '\n…(truncated)' : ''}`;
+      return `${rel}:\n${keepWhole(data)}`;
     } catch (e) { return `Couldn't read ${rel}: ${e.message}`; }
   }
   // EDIT beats WRITE for changing part of a file: WRITE overwrites the whole
@@ -1090,7 +1119,7 @@ async function tryDirective(reply, originId) {
           + `directive instead:\n  MCP: ${url}\nto list its tools, then\n  `
           + `MCP: ${url} | <tool> | {"arg": "value"}\nto call one.`;
       }
-      return `${url} (${r.status}):\n${text.slice(0, 8000)}${text.length > 8000 ? '\n…(truncated)' : ''}`;
+      return `${url} (${r.status}):\n${keepWhole(text)}`;
     } catch (e) { return `Couldn't fetch ${url}: ${e.message}`; }
   }
 
@@ -1194,7 +1223,7 @@ async function mcpDirective(url, tool, args) {
     const out = (res?.content || [])
       .map((c) => (c.type === 'text' ? c.text : `[${c.type}]`))
       .join('\n') || JSON.stringify(res ?? call.raw);
-    return `${banner}\n$ ${tool}\n${out.slice(0, 6000)}${out.length > 6000 ? '\n…(truncated)' : ''}`;
+    return `${banner}\n$ ${tool}\n${keepWhole(out)}`;
   } catch (e) {
     return `MCP ${url}: ${e.message}`;
   }
@@ -1288,8 +1317,16 @@ async function runTurn(threadId, userText, onEvent, images) {
     // user a turn and told them nothing. Retry once before giving up, and if
     // it is still empty, say what actually happened instead of "(no
     // response)", which reads like the harness broke.
-    if (!reply) reply = await ask();
-    if (!reply) reply = '(the model returned an empty completion — usually a transient provider hiccup or a stop-sequence firing early. Say "continue" to retry.)';
+    // Retry in place rather than parking the thread behind a note the user has
+    // to answer. In auto especially: a transient blip must not become a manual
+    // step, which is the whole point of auto.
+    for (let i = 0; !reply && i < AUTO_EMPTY_RETRIES; i++) {
+      await new Promise((r) => setTimeout(r, 400 * (i + 1)));
+      reply = await ask();
+    }
+    if (!reply) {
+      reply = `(the model returned nothing ${AUTO_EMPTY_RETRIES + 1} times — that is a provider problem, not your input. Try /model to switch, or send anything to retry.)`;
+    }
   } catch (e) {
     reply = `error: ${e.message}`;
   }
@@ -1323,7 +1360,7 @@ async function runTurn(threadId, userText, onEvent, images) {
         bindThread(t).catch(() => {});
         runTurn(threadId, condense('(command output)', output), onEvent).catch(() => {});
       } else {
-        const note = `(auto-run stopped after ${AUTO_MAX_STEPS} chained commands — say "continue" to keep going)`;
+        const note = `(auto-run paused after ${AUTO_MAX_STEPS} chained commands — that is the spend ceiling, not the end of the job. Send anything to carry on, or raise OZ_AUTO_MAX_STEPS.)`;
         t.history.push({ who: 'bot', text: note });
         onEvent?.({ type: 'final', name: t.name, color: t.color, text: note });
         saveThreads();
@@ -1368,7 +1405,7 @@ async function runTurn(threadId, userText, onEvent, images) {
       runTurn(threadId, condense('(directive result)', ack), onEvent).catch(() => {});
       return;
     }
-    const note = `(auto stopped after ${AUTO_MAX_STEPS} steps — say "continue" to keep going)`;
+    const note = `(auto paused after ${AUTO_MAX_STEPS} steps — that is the spend ceiling, not the end of the job. Send anything to carry on, or raise OZ_AUTO_MAX_STEPS.)`;
     t.history.push({ who: 'bot', text: note });
     onEvent?.({ type: 'final', name: t.name, color: t.color, text: note });
     saveThreads();

package/package.json

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