openzoo 0.48.8 → 0.48.10

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';
 
@@ -336,6 +336,18 @@ function newGroupThread(names) {
 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);
+// 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.
+//
+// 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.
 //
@@ -575,7 +587,10 @@ async function handleSlash(task, t) {
       + '  FETCH: <url>                        read a page’s text\n'
       + '  MCP: <url> [| tool | {json}]        list or call MCP tools\n'
       + '  TODO: <lines>                       visible checklist\n'
-      + '  SPAWN / SEND / PING / PEEK          other bots\n\n'
+      + '  SPAWN: <name> | <task>              a NEW subagent (names are unique —\n'
+      + '                                      spawning an existing one sends to it)\n'
+      + '  SEND: <name> | <msg>                more work for an EXISTING subagent\n'
+      + '  PING / PEEK                         reach or inspect another bot\n\n'
       + 'READ, LS, GLOB, GREP, FETCH, PEEK and MCP run CONCURRENTLY when several\n'
       + 'appear in one reply — four files cost one round trip, not four.';
   }
@@ -776,6 +791,26 @@ async function tryDirective(reply, originId) {
   if (spawn) {
     const name = spawn[1].trim();
     const task = spawn[2].trim();
+    // NAMES ARE UNIQUE. This used to call newThread() unconditionally, so a
+    // model asked to "keep spawning" produced FIFTEEN threads all called
+    // tetris-contract, each one a live agent burning paid calls, and the
+    // sidebar became an unusable wall of identical rows. A repeat SPAWN is
+    // almost always the model re-issuing work for the same worker, not asking
+    // for a second identical one — so route it to the existing thread, which
+    // is what SEND already does.
+    const existing = findByName(name);
+    if (existing) {
+      runTurn(existing.id, task).catch(() => {});
+      return `${name} already exists — sent it the task instead of spawning a duplicate.`;
+    }
+    // Storm guard. Fire-and-forget spawning is unbounded by construction: each
+    // child can spawn, and nothing above it is counting.
+    const siblings = [...threads.values()].filter((x) => x.parent === originId).length;
+    if (siblings >= SPAWN_MAX_CHILDREN) {
+      return `Not spawning "${name}": this thread already has ${siblings} subagents `
+        + `(limit ${SPAWN_MAX_CHILDREN}). Reuse one with  SEND: <name> | <task>  — `
+        + `every live subagent costs paid calls.`;
+    }
     const sub = newThread(name, originId);
     runTurn(sub.id, task).catch(() => {}); // fire and forget — runs independently
     return `Spawned ${name} — working on it.`;

package/package.json

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