@yemi33/minions 0.1.1048 → 0.1.1050

package/CHANGELOG.md

@@ -1,12 +1,16 @@
 # Changelog
 
-## 0.1.1048 (2026-04-17)
+## 0.1.1050 (2026-04-17)
+
+### Features
+- seed realActivityMap at spawn time, stamp pid in live-output (#1200)
 
 ### Fixes
 - stamp live-output.log stub before spawn (#1198)
 -  harden settings save and migrate pr poll config
 
 ### Other
+- chore: raise default meeting round timeout
 - Harden prompt context handling
 - Harden loop watch conversion
 - Add watches sidebar activity badge

package/dashboard/js/settings.js

@@ -45,7 +45,7 @@ async function openSettings() {
       settingsField('Idle Alert', 'set-idleAlertMinutes', e.idleAlertMinutes || 15, 'min', 'Alert after agent idle this long') +
       settingsField('Shutdown Timeout', 'set-shutdownTimeout', e.shutdownTimeout || 300000, 'ms', 'Max wait for agents during graceful shutdown') +
       settingsField('Restart Grace Period', 'set-restartGracePeriod', e.restartGracePeriod || 1200000, 'ms', 'Grace period before orphan detection on restart') +
-      settingsField('Meeting Round Timeout', 'set-meetingRoundTimeout', e.meetingRoundTimeout || 600000, 'ms', 'Auto-advance meeting round after this') +
+      settingsField('Meeting Round Timeout', 'set-meetingRoundTimeout', e.meetingRoundTimeout || 900000, 'ms', 'Auto-advance meeting round after this') +
     '</div>' +
     '<div style="display:flex;flex-direction:column;gap:6px;margin-bottom:16px">' +
       settingsToggle('Auto-approve Plans', 'set-autoApprovePlans', !!e.autoApprovePlans, 'PRDs are approved automatically without human review') +

package/engine/shared.js

@@ -695,7 +695,7 @@ const ENGINE_DEFAULTS = {
   autoArchive: false, // opt-in: auto-archive plans after verify completes (false = mark ready, user archives manually)
   autoFixConflicts: true, // auto-dispatch fix agents when a PR has merge conflicts
   autoFixBuilds: true, // auto-dispatch fix agents when a PR build fails
-  meetingRoundTimeout: 600000, // 10min per meeting round before auto-advance
+  meetingRoundTimeout: 900000, // 15min per meeting round before auto-advance
   evalLoop: true, // enable review→fix loop after implementation completes
   evalMaxIterations: 3, // max review→fix cycles before escalating to human
   evalMaxCost: null, // USD ceiling per work item across all eval iterations; null = no limit (gather baseline data first)

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.1050",
   "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"