openzoo 0.48.9 → 0.48.11

package/lib/grokui.mjs

@@ -9,7 +9,7 @@ import { exec } from 'node:child_process';
 import http from 'node:http';
 import { randomUUID } from 'node:crypto';
 import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
-import { homedir } from 'node:os';
+import { cpus, homedir } from 'node:os';
 import path from 'node:path';
 import { brain, brainStream, MODEL, PROXY } from './podagent.mjs';
 
@@ -29,7 +29,17 @@ const STORE_FILE = path.join(STORE_DIR, 'grokui-threads.json');
 // chat. safeResolveIn rejects any path that would escape that thread's root
 // (../, absolute paths, symlink tricks via normalize) — access is real, but
 // always contained to whatever root was explicitly chosen for that thread.
-const WORKSPACE_DIR = path.join(homedir(), '.openzoo', 'grokui-workspace');
+// Where a thread's WRITE/READ/RUN/LS/GLOB/GREP are scoped by default.
+//
+// Overridable because a BOX puts uploaded files somewhere else: box-server
+// unpacks them into /workspace, while this defaulted to ~/.openzoo/grokui-
+// workspace. So a user uploaded a 670-part archive, asked a bot to find it,
+// and got "GLOB **/prooffront: no matches" — the bot was searching an empty
+// directory and looked broken while the files sat one path away. The site had
+// resorted to printing "grokui: /dir /workspace" as a hint for the user to
+// fix it by hand every time.
+const WORKSPACE_DIR = process.env.OZ_WORKSPACE_DIR
+  || path.join(homedir(), '.openzoo', 'grokui-workspace');
 mkdirSync(WORKSPACE_DIR, { recursive: true });
 function expandHome(p) { return p.startsWith('~') ? path.join(homedir(), p.slice(1)) : p; }
 function dirFor(threadId) { return threads.get(threadId)?.dir || WORKSPACE_DIR; }
@@ -339,7 +349,15 @@ const AUTO_MAX_STEPS = Number(process.env.OZ_AUTO_MAX_STEPS || 8);
 // 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.
-const SPAWN_MAX_CHILDREN = Number(process.env.OZ_SPAWN_MAX_CHILDREN || 12);
+//
+// Scaled to the box rather than a magic number: a 2-core container and a
+// 32-core one should not get the same allowance. Agents are network-bound, not
+// CPU-bound — they spend their time waiting on the model — so the multiplier
+// is generous, and cores are a proxy for "how big is this machine" rather than
+// a real parallelism limit. The honest limit is money, which is why the
+// refusal message says so.
+const SPAWN_MAX_CHILDREN = Number(process.env.OZ_SPAWN_MAX_CHILDREN)
+  || Math.max(8, (cpus()?.length || 2) * 4);
 
 // Injected fresh on every AUTO turn, never persisted into the thread.
 //
@@ -1219,10 +1237,18 @@ async function runTurn(threadId, userText, onEvent, images) {
   }
   if (t.runMode === 'auto') extras.push({ role: 'system', content: AUTO_DIRECTIVE });
   const callMsgs = extras.length ? [...t.messages, ...extras] : t.messages;
+  const ask = async () => (onEvent
+    ? (await brainStream(callMsgs, (delta) => onEvent({ type: 'delta', name: t.name, color: t.color, delta }), t.contextId, t.model)).trim()
+    : (await brain(callMsgs, t.contextId, t.model)).trim());
   try {
-    reply = onEvent
-      ? (await brainStream(callMsgs, (delta) => onEvent({ type: 'delta', name: t.name, color: t.color, delta }), t.contextId, t.model)).trim()
-      : (await brain(callMsgs, t.contextId, t.model)).trim();
+    reply = await ask();
+    // An EMPTY completion is transient far more often than it is meaningful —
+    // it showed up repeatedly as a dead "(no response)" bubble that cost the
+    // 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.)';
   } catch (e) {
     reply = `error: ${e.message}`;
   }
@@ -1275,6 +1301,29 @@ async function runTurn(threadId, userText, onEvent, images) {
   t.status = 'idle';
   t.lastActivityAt = Date.now();
   saveThreads();
+
+  // AUTO CONTINUES AFTER *ANY* DIRECTIVE, not just RUN.
+  //
+  // Only the RUN branch above fed its output back and looped, so a turn that
+  // used SPAWN / WRITE / EDIT / MCP / GLOB executed one directive, posted its
+  // ack, and stopped dead — the user had to type "continue" to get each
+  // subsequent step, on every single turn, which is not what auto means. The
+  // model never saw its own directive's result either, so it could not react
+  // to "no matches" or "already exists".
+  //
+  // Same budget as RUN (shared t.autoSteps, reset when the user speaks), so
+  // this cannot spend more than a chained RUN loop already could.
+  if (t.runMode === 'auto' && ack !== null && ack !== undefined) {
+    t.autoSteps = (t.autoSteps || 0) + 1;
+    if (t.autoSteps < AUTO_MAX_STEPS) {
+      runTurn(threadId, `(directive result)\n${ack}`, onEvent).catch(() => {});
+      return;
+    }
+    const note = `(auto stopped after ${AUTO_MAX_STEPS} steps — say "continue" to keep going)`;
+    t.history.push({ who: 'bot', text: note });
+    onEvent?.({ type: 'final', name: t.name, color: t.color, text: note });
+    saveThreads();
+  }
   bindThread(t).catch(() => {});
 }
 

package/package.json

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