@yemi33/minions 0.1.1048 → 0.1.1049

package/CHANGELOG.md

@@ -1,6 +1,9 @@
 # Changelog
 
-## 0.1.1048 (2026-04-17)
+## 0.1.1049 (2026-04-17)
+
+### Features
+- seed realActivityMap at spawn time, stamp pid in live-output (#1200)
 
 ### Fixes
 - stamp live-output.log stub before spawn (#1198)

package/engine/timeout.js

@@ -308,15 +308,33 @@ function checkTimeouts(config) {
     const procInfo = activeProcesses.get(item.id);
     if (procInfo?._steeringAt && Date.now() - procInfo._steeringAt < 60000) continue;
 
-    // Capture live-output.log file state for orphan/hung diagnostics (#W-mo248lkjwgsu).
-    // Three distinguishable failure modes:
-    //   logExists=false           → spawn call itself threw, no log ever written
-    //   logExists=true, size~stub → process died at startup (stub-only content)
-    //   logExists=true, size>stub → genuine hang (process alive, wrote output, then stopped)
-    let _logState = 'logExists=false logSize=0';
+    // Capture live-output.log file state for orphan/hung diagnostics
+    // (#W-mo248lkjwgsu original, #W-mo25loq8kjer pid annotation).
+    // Four distinguishable failure modes:
+    //   logExists=false                         → spawn call itself threw, no log ever written
+    //   logExists=true pidPresent=false         → engine stub written but spawn died before emitting pid line
+    //   logExists=true pidPresent=true silent   → process spawned (pid recorded) but never produced stdout
+    //   logExists=true pidPresent=true size>pid → genuine hang (process wrote output then stopped)
+    //
+    // The pid line `[<iso>] pid: <N>` is stamped by engine.js immediately after runFile() returns.
+    // Its presence → the child process was actually spawned; absence → spawn itself failed or the
+    // appendFileSync on the pid line threw (rare).
+    let _logState = 'logExists=false logSize=0 pidPresent=false';
     try {
       const lst = fs.statSync(liveLogPath);
-      _logState = `logExists=true logSize=${lst.size}`;
+      // Read only the head (4KB) — pid line is written right after the stub, always near the top.
+      // Avoids loading the full log just for a diagnostic annotation.
+      let pidPresent = false;
+      try {
+        const fd = fs.openSync(liveLogPath, 'r');
+        const headSize = Math.min(lst.size, 4096);
+        const headBuf = Buffer.alloc(headSize);
+        fs.readSync(fd, headBuf, 0, headSize, 0);
+        fs.closeSync(fd);
+        // Match `] pid: <digits>` — agnostic to ISO timestamp format at the start.
+        pidPresent = /\]\s+pid:\s+\d+/.test(headBuf.toString('utf8'));
+      } catch { /* read failure — pidPresent stays false */ }
+      _logState = `logExists=true logSize=${lst.size} pidPresent=${pidPresent}`;
     } catch { /* ENOENT — keep default */ }
 
     if (!hasProcess && silentMs > effectiveTimeout && (Date.now() > engineRestartGraceUntil || engineRestartGraceExempt?.has(item.id))) {

package/engine.js

@@ -916,6 +916,23 @@ async function spawnAgent(dispatchItem, config) {
     throw spawnErr;
   }
 
+  // Seed realActivityMap and stamp PID immediately — BEFORE any handlers or timers (#W-mo25loq8kjer).
+  // Why NOW, not later in the function:
+  //  1. Heartbeat clock anchoring. timeout.js uses realActivityMap as the last-activity timestamp for
+  //     tracked processes; when the map has no entry, it falls back to item.started_at (dispatch time,
+  //     which is 20-60s before actual spawn for write tasks doing worktree setup). Read-only tasks
+  //     that produce no stdout for minutes (explore, security audit, large scans) were hitting
+  //     heartbeatTimeout prematurely — clock had already been running since dispatch.
+  //  2. Error-handler race. The `proc.on('error', ...)` handler below calls realActivityMap.delete(id)
+  //     on synchronous spawn failures. Seeding before registering handlers ensures delete sees a value
+  //     to clear rather than leaving an absent-then-absent no-op that downstream code must guard.
+  //  3. Orphan diagnostics. The PID line gives timeout.js a deterministic way to tell "spawn died
+  //     before first write" (stub-only log) from "process started and is hung" (stub + pid line).
+  realActivityMap.set(id, Date.now());
+  try {
+    fs.appendFileSync(liveOutputPath, `[${new Date().toISOString()}] pid: ${proc.pid ?? 'unknown'}\n`);
+  } catch { /* log stamp is best-effort — don't block spawn on fs failure */ }
+
   const MAX_OUTPUT = 1024 * 1024; // 1MB
   let stdout = '';
   let stderr = '';
@@ -1292,9 +1309,11 @@ async function spawnAgent(dispatchItem, config) {
     }
   }, 3000);
 
-  // Track process — even if PID isn't available yet (async on Windows)
+  // Track process — even if PID isn't available yet (async on Windows).
+  // realActivityMap was already seeded immediately after runFile() returned (#W-mo25loq8kjer);
+  // don't re-seed here — the stdout/stderr handlers above can already have updated it with
+  // a fresher timestamp, and overwriting would clobber the real "last activity" signal.
   activeProcesses.set(id, { proc, agentId, startedAt, sessionId: cachedSessionId });
-  realActivityMap.set(id, Date.now()); // Initialize real activity at spawn time
 
   updateAgentStatus(id, AGENT_STATUS.RUNNING, `Process spawned for ${agentId}`);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.1048",
+  "version": "0.1.1049",
   "description": "Multi-agent AI dev team that runs from ~/.minions/ — five autonomous agents share a single engine, dashboard, and knowledge base",
   "bin": {
     "minions": "bin/minions.js"