neohive 6.1.1 → 6.1.2

package/cli.js

@@ -718,6 +718,22 @@ function reset() {
     console.log('  [warn] Could not archive: ' + e.message + ' — proceeding with reset anyway.');
   }
 
+  // Kill any running MCP server processes before wiping data.
+  // Otherwise orphaned heartbeat intervals keep writing into the fresh directory.
+  try {
+    const agentsFile = path.join(targetDir, 'agents.json');
+    if (fs.existsSync(agentsFile)) {
+      const agents = JSON.parse(fs.readFileSync(agentsFile, 'utf8'));
+      let killed = 0;
+      for (const [name, info] of Object.entries(agents)) {
+        if (info.pid) {
+          try { process.kill(info.pid, 'SIGTERM'); killed++; } catch {}
+        }
+      }
+      if (killed > 0) console.log('  [ok] Terminated ' + killed + ' running agent process(es)');
+    }
+  } catch {}
+
   fs.rmSync(targetDir, { recursive: true, force: true });
   fs.mkdirSync(targetDir, { recursive: true });
   console.log('  Cleared all data from ' + targetDir);

package/dashboard.js

@@ -313,22 +313,23 @@ function readJson(file) {
 }
 
 function isPidAlive(pid, lastActivity) {
-  const STALE_THRESHOLD = 30000; // 30s — 3x heartbeat interval, catches dead agents faster
+  const STALE_THRESHOLD = 30000; // 30s — 3x heartbeat interval
+  const PID_TRUST_WINDOW = 60000; // 60s — beyond this, PID check is unreliable (OS reuses PIDs)
 
-  // PRIORITY 1: Trust heartbeat freshness over PID status
-  // Heartbeats are written by the actual running process — if fresh, agent is alive
-  // regardless of whether process.kill can see the PID
   if (lastActivity) {
     const stale = Date.now() - new Date(lastActivity).getTime();
     if (stale < STALE_THRESHOLD) return true;
+    // A real neohive agent writes heartbeat every 10s. If 60s have passed
+    // without one, the PID belongs to a different process (OS recycled it).
+    if (stale > PID_TRUST_WINDOW) return false;
   }
 
-  // PRIORITY 2: If heartbeat is stale, check PID as fallback
+  // Heartbeat is stale but within the trust window — verify PID as fallback
   try {
     process.kill(pid, 0);
-    return true; // PID exists — alive even with stale heartbeat
+    return true;
   } catch {
-    return false; // PID dead AND heartbeat stale — truly dead
+    return false;
   }
 }
 
@@ -3967,12 +3968,17 @@ function startFileWatcher() {
 
 startFileWatcher();
 
-// macOS fs.watch() loses its handle when files are deleted and recreated (e.g. reset --force).
-// Periodically verify the watcher is still alive and restart if needed.
+// macOS fs.watch() silently stops emitting events when the watched directory is
+// deleted and recreated (e.g. reset --force). The watcher object stays non-null
+// but is dead. Force-restart it every 30s to guarantee the dashboard stays live.
+let _lastWatcherRestart = Date.now();
 setInterval(() => {
   const dataDir = resolveDataDir();
   if (!fs.existsSync(dataDir)) return;
-  if (!fsWatcher) startFileWatcher();
+  if (!fsWatcher || Date.now() - _lastWatcherRestart > 30000) {
+    startFileWatcher();
+    _lastWatcherRestart = Date.now();
+  }
 }, 5000).unref();
 
 server.on('error', (err) => {

package/lib/agents.js

@@ -12,6 +12,7 @@ const _pidAliveCache = {};
 let _isAutonomousMode = () => false;
 function setAutonomousModeCheck(fn) { _isAutonomousMode = fn; }
 
+const PID_TRUST_WINDOW_MS = 60000;
 function isPidAlive(pid, lastActivity) {
   const cacheKey = `${pid}_${lastActivity}`;
   const cached = _pidAliveCache[cacheKey];
@@ -22,9 +23,14 @@ function isPidAlive(pid, lastActivity) {
 
   if (lastActivity) {
     const stale = Date.now() - new Date(lastActivity).getTime();
-    if (stale < STALE_THRESHOLD) alive = true;
-  }
-  if (!alive) {
+    if (stale < STALE_THRESHOLD) {
+      alive = true;
+    } else if (stale > PID_TRUST_WINDOW_MS) {
+      alive = false;
+    } else {
+      try { process.kill(pid, 0); alive = true; } catch { alive = false; }
+    }
+  } else {
     try { process.kill(pid, 0); alive = true; } catch { alive = false; }
   }
   _pidAliveCache[cacheKey] = { alive, ts: Date.now() };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neohive",
-  "version": "6.1.1",
+  "version": "6.1.2",
   "description": "The MCP collaboration layer for AI CLI tools. Turn Claude Code, Gemini CLI, and Codex CLI into a team.",
   "main": "server.js",
   "bin": {

package/server.js

@@ -454,40 +454,33 @@ function getAcks() {
   }
 }
 
-// Cache for isPidAlive results — avoids redundant process.kill calls at 100-agent scale
 const _pidAliveCache = {};
+const PID_TRUST_WINDOW_MS = 60000; // Beyond 60s without heartbeat, PID is unreliable (OS reuses PIDs)
 function isPidAlive(pid, lastActivity) {
-  // Cache with 5s TTL — PID status doesn't change faster than heartbeats
   const cacheKey = `${pid}_${lastActivity}`;
   const cached = _pidAliveCache[cacheKey];
   if (cached && Date.now() - cached.ts < SERVER_CONFIG.AGENT_CACHE_TTL_MS) return cached.alive;
 
-  // 30s stale threshold — 3x the 10s heartbeat interval, catches dead agents faster
   const STALE_THRESHOLD = SERVER_CONFIG.AGENT_STALE_THRESHOLD_MS;
   let alive = false;
 
-  // PRIORITY 1: Trust heartbeat freshness over PID status
-  // Heartbeat files are written by the actual running process — if fresh, agent is alive
-  // regardless of whether process.kill can see the PID (cross-process PID visibility issues)
   if (lastActivity) {
     const stale = Date.now() - new Date(lastActivity).getTime();
     if (stale < STALE_THRESHOLD) {
       alive = true;
-    }
-  }
-
-  // PRIORITY 2: If heartbeat is stale, verify PID is actually dead
-  if (!alive) {
-    try {
-      process.kill(pid, 0);
-      alive = true; // PID exists — agent is alive even with stale heartbeat
-    } catch {
-      // PID dead AND heartbeat stale — agent is truly dead
+    } else if (stale > PID_TRUST_WINDOW_MS) {
+      // A real neohive agent writes heartbeat every 10s. If 60s have passed
+      // without one, the PID belongs to a different process (OS recycled it).
       alive = false;
+    } else {
+      // Within trust window — verify PID as fallback
+      try { process.kill(pid, 0); alive = true; } catch { alive = false; }
     }
+  } else {
+    try { process.kill(pid, 0); alive = true; } catch { alive = false; }
   }
+
   _pidAliveCache[cacheKey] = { alive, ts: Date.now() };
-  // Evict old entries (keep cache small)
   const keys = Object.keys(_pidAliveCache);
   if (keys.length > 200) {
     const cutoff = Date.now() - SERVER_CONFIG.POLL_INTERVAL_MS * 5;