ruvnet-brain 3.9.134-dev → 4.0.2

package/plugin/mcp/server.mjs

@@ -37,7 +37,7 @@ import { callManagedCli, MANAGED_CLI_TOOLS } from './managed-cli-interface.mjs';
 
 const BRAIN_HOME = process.env.RUVNET_BRAIN_HOME || path.join(os.homedir(), '.cache', 'ruvnet-brain');
 const KB = process.env.RUVNET_BRAIN_KB || path.join(BRAIN_HOME, 'kb');
-const CHILD_MCP = path.join(KB, 'forge-mcp-all.mjs');
+const CHILD_MCP = process.env.RUVNET_BRAIN_CHILD_MCP || path.join(KB, 'forge-mcp-all.mjs');
 const ACTIVE = path.join(BRAIN_HOME, 'active.json');
 const LEASES = path.join(BRAIN_HOME, 'leases');
 const LEASE = path.join(LEASES, `mcp-${process.pid}.json`);
@@ -95,10 +95,33 @@ let child = null;            // { proc, generation, nextId, pending: Map<childId
 let pendingCount = 0;        // client tools/call requests currently in flight (drain gate for swaps)
 let childRetirement = Promise.resolve();
 let childStartup = null;
+let childIdleTimer = null;
 const CHILD_TERM_GRACE_MS = 3_000;
 const CHILD_INIT_TIMEOUT_MS = Number(process.env.RUVNET_BRAIN_INIT_TIMEOUT_MS) || 60_000;
+const CHILD_IDLE_MS = Number(process.env.RUVNET_BRAIN_CHILD_IDLE_MS) || 30 * 60_000;
+
+function clearChildIdleTimer() {
+  if (childIdleTimer) clearTimeout(childIdleTimer);
+  childIdleTimer = null;
+}
+
+function armChildIdleTimer(c = child) {
+  clearChildIdleTimer();
+  if (!c || CHILD_IDLE_MS <= 0) return;
+  childIdleTimer = setTimeout(() => {
+    childIdleTimer = null;
+    if (child !== c) return;
+    if (pendingCount > 0 || c.pending.size > 0 || childStartup) {
+      armChildIdleTimer(c);
+      return;
+    }
+    void killChild(`idle for ${CHILD_IDLE_MS / 1000}s`);
+  }, CHILD_IDLE_MS);
+  childIdleTimer.unref?.();
+}
 
 function killChild(reason) {
+  clearChildIdleTimer();
   if (!child) return childRetirement;
   const c = child; child = null;
   for (const [, p] of c.pending) p.reject(new Error(`brain worker ${reason}`));
@@ -124,6 +147,10 @@ function killChild(reason) {
 async function ensureChild() {
   const gen = currentGeneration();
   if (child && child.generation !== gen && pendingCount === 0) await killChild('superseded by a newer generation');
+  // A concurrent initialize/tools-list/tools-call must join the same readiness promise. Returning
+  // `child` while its private initialize or model warmup is still running advertises a half-ready
+  // worker and charges cold-start to the first user call.
+  if (childStartup) return childStartup;
   if (child) return child;
   await childRetirement;
   if (!fs.existsSync(CHILD_MCP)) return null;
@@ -154,10 +181,22 @@ async function ensureChild() {
           capabilities: {},
           clientInfo: { name: 'ruvnet-brain-shell', version: SERVER_INFO.version },
         }, CHILD_INIT_TIMEOUT_MS);
+        const warmed = await childRequest(c, 'brain/warmup', {}, CHILD_INIT_TIMEOUT_MS);
+        // Rolling-upgrade compatibility: 4.0.1 workers predate the private warmup extension. The
+        // stable shell is installed before the 700MB KB swap completes, so rejecting -32601 here
+        // makes every query fail during the exact in-place upgrade window the shell exists to hide.
+        // An older initialized worker is usable (its first query may be cold); any other warmup
+        // failure still fails closed.
+        const warmupUnsupported = warmed.error?.code === -32601
+          || /method not found/i.test(String(warmed.error?.message || ''));
+        if (!warmupUnsupported && (warmed.error || warmed.result?.ready !== true)) {
+          throw new Error(warmed.error?.message || 'brain worker did not confirm warm readiness');
+        }
       } catch (e) {
         await killChild('failed initialize');
         throw new Error(`brain worker failed to initialize: ${e.message}`);
       }
+      armChildIdleTimer(c);
       return c;
     })();
   }
@@ -191,10 +230,11 @@ async function onChildTimeout(method, timeoutMs) {
   }
 }
 
-// Overridable so the outage path above can actually be TESTED — a 120s default is untestable, and
-// an untestable failure path is how this one went four days reporting "ok" while it was down. Also
-// genuinely useful in the field: a slow machine can raise it, and a CI runner can lower it.
-const CALL_TIMEOUT_MS = Number(process.env.RUVNET_BRAIN_CALL_TIMEOUT_MS) || 120_000;
+// Overridable so the outage path above can actually be TESTED. The default matches the installer's
+// real cold-start smoke budget: measured 153s after a cache repair on 2026-07-29. A 120s parent
+// deadline killed the model just before it became usable and forced every retry to start cold.
+// Steady-state latency remains a separate release gate; this budget prevents a permanent cold loop.
+const CALL_TIMEOUT_MS = Number(process.env.RUVNET_BRAIN_CALL_TIMEOUT_MS) || 240_000;
 
 function childRequest(c, method, params, timeoutMs = CALL_TIMEOUT_MS) {
   return new Promise((resolve, reject) => {
@@ -216,6 +256,12 @@ async function handleClient(msg) {
   if (id === undefined || id === null) return; // notifications need no answer
   switch (method) {
     case 'initialize':
+      // MCP initialize itself stays protocol-fast; normal clients request tools/list immediately
+      // afterwards, which joins this readiness promise and does not receive the tool declaration
+      // until the worker's query embedder and cross-encoder are warm.
+      void ensureChild().catch((e) => {
+        console.error(`[ruvnet-brain] worker warmup failed during initialize: ${e.message}`);
+      });
       return clientOk(id, { protocolVersion: PROTOCOL_VERSION, capabilities: { tools: {} }, serverInfo: SERVER_INFO });
     case 'ping':
       return clientOk(id, {});
@@ -225,7 +271,10 @@ async function handleClient(msg) {
         if (c) {
           try {
             const r = await childRequest(c, 'tools/list', {}, 15_000);
-            if (r.result?.tools?.length) return clientOk(id, { ...r.result, tools: withLocalTools(r.result.tools) });
+            if (r.result?.tools?.length) {
+              armChildIdleTimer(c);
+              return clientOk(id, { ...r.result, tools: withLocalTools(r.result.tools) });
+            }
           }
           catch { /* fall through to the static declaration */ }
         }
@@ -259,6 +308,7 @@ async function handleClient(msg) {
         return clientOk(id, { content: [{ type: 'text', text: `search_ruvnet error: ${e.message}` }], isError: true });
       } finally {
         pendingCount--;
+        armChildIdleTimer(c);
       }
     }
     default: