@yemi33/minions 0.1.1761 → 0.1.1763

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.1.1762 (2026-05-07)
+
+### Fixes
+- detach agent process group so engine death never kills agents
+
 ## 0.1.1761 (2026-05-07)
 
 ### Fixes

package/engine/cleanup.js

@@ -48,6 +48,67 @@ function worktreeMatchesBranch(dirLower, branch, actualBranch = '') {
   return worktreeBranchMatches(actualBranch, branch) || worktreeDirMatchesBranch(dirLower, branch);
 }
 
+/**
+ * Sweep leaked test-fixture meetings from a `meetings/` directory.
+ *
+ * Meeting unit/integration tests don't all honor MINIONS_TEST_DIR
+ * (engine/meeting.js is in ISOLATED_MODULES, but tests that load it after the
+ * env var is unset, or that fail before cleanup, leave `.json` + `.json.backup`
+ * sidecars behind). The engine's tick loop then re-discovers these fixtures
+ * every tick, fails playbook validation ("missing required template variables:
+ * agenda"), and spams log.json with the same error.
+ *
+ * Filter is conservative: only files whose ID begins with `TEST-` AND whose
+ * JSON either lacks an `agenda` or has an empty/whitespace-only one. Both the
+ * live `.json` and any `.json.backup` sidecar (which would otherwise
+ * auto-restore the file via safeJson on next read) are removed together.
+ *
+ * Returns the number of files unlinked.
+ */
+function sweepLeakedTestMeetings(meetingsDir) {
+  let cleaned = 0;
+  try {
+    if (!fs.existsSync(meetingsDir)) return 0;
+    const candidates = new Set();
+    for (const f of fs.readdirSync(meetingsDir)) {
+      if (!f.startsWith('TEST-')) continue;
+      // Match "<id>.json" or "<id>.json.backup" — both belong to the same fixture
+      const idMatch = f.match(/^(TEST-[^/]+?)\.json(\.backup)?$/);
+      if (!idMatch) continue;
+      candidates.add(idMatch[1]);
+    }
+    for (const id of candidates) {
+      const livePath = path.join(meetingsDir, `${id}.json`);
+      const backupPath = `${livePath}.backup`;
+      // Decide whether to delete based on the live file's contents, falling
+      // back to the .backup sidecar if the live file is missing/corrupt.
+      let agendaPresent = false;
+      let saw = false;
+      for (const candidatePath of [livePath, backupPath]) {
+        try {
+          const data = JSON.parse(fs.readFileSync(candidatePath, 'utf8'));
+          saw = true;
+          if (data && typeof data.agenda === 'string' && data.agenda.trim()) {
+            agendaPresent = true;
+            break;
+          }
+        } catch { /* missing or corrupt — try next candidate */ }
+      }
+      // Delete only when we confirmed the fixture exists AND has no usable
+      // agenda. If neither file parses (saw=false), the directory entry is
+      // already useless; unlink both so safeJson can't resurrect it.
+      if (saw && agendaPresent) continue;
+      for (const target of [livePath, backupPath]) {
+        try { fs.unlinkSync(target); cleaned++; } catch { /* not present */ }
+      }
+    }
+    if (cleaned > 0) {
+      log('info', `Cleaned ${cleaned} leaked test-fixture meeting file(s) from ${meetingsDir}`);
+    }
+  } catch (e) { log('warn', 'cleanup leaked test meetings: ' + e.message); }
+  return cleaned;
+}
+
 function getWorktreeBranch(wtPath) {
   try {
     return exec(`git -C "${wtPath}" branch --show-current`, { encoding: 'utf8', stdio: 'pipe', timeout: 5000, windowsHide: true }).trim();
@@ -418,6 +479,9 @@ async function runCleanup(config, verbose = false) {
   // 5. Clean spawn-debug.log
   try { fs.unlinkSync(path.join(ENGINE_DIR, 'spawn-debug.log')); } catch { /* cleanup */ }
 
+  // 5b. Sweep leaked test-fixture meetings from the live `meetings/` directory.
+  cleaned.leakedTestMeetings = sweepLeakedTestMeetings(path.join(MINIONS_DIR, 'meetings'));
+
   // 6. Prune old output archive files (keep last 30 per agent)
   for (const agentId of Object.keys(config.agents || {})) {
     const agentDir = path.join(MINIONS_DIR, 'agents', agentId);
@@ -862,6 +926,7 @@ function scrubStaleMetrics() {
 module.exports = {
   runCleanup,
   scrubStaleMetrics,
+  sweepLeakedTestMeetings,   // exported for testing
   worktreeDirMatchesBranch,  // exported for testing
   worktreeMatchesBranch,     // exported for testing
   getWorktreeBranch,         // exported for lifecycle cleanup

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-05-07T00:43:24.079Z"
+  "cachedAt": "2026-05-07T01:02:34.683Z"
 }

package/engine/github.js

@@ -109,9 +109,13 @@ function recordSlugFailure(slug) {
   const backoffMs = Math.min(GH_POLL_BACKOFF_BASE_MS * Math.pow(2, failures - 1), GH_POLL_BACKOFF_MAX_MS);
   _ghPollBackoff.set(slug, { failures, backoffUntil: Date.now() + backoffMs });
   if (failures === 1) {
+    // First failure is genuinely actionable — surface it.
     log('warn', `GitHub poll: repo ${slug} failed — will retry in ${Math.round(backoffMs / 1000)}s`);
   } else {
-    log('warn', `GitHub poll: repo ${slug} failed ${failures} times — backoff ${Math.round(backoffMs / 1000)}s`);
+    // Subsequent escalations are deterministic backoff math — info, not warn.
+    // We already warned on the first failure; spamming the same operator
+    // with 12 escalation lines per outage adds no signal.
+    log('info', `GitHub poll: repo ${slug} failed ${failures} times — backoff ${Math.round(backoffMs / 1000)}s`);
   }
 }
 

package/engine/lifecycle.js

@@ -1956,7 +1956,10 @@ function checkForLearnings(agentId, agentInfo, taskDesc) {
     log('info', `${agentInfo?.name || agentId} wrote ${agentFiles.length} finding(s) to inbox`);
     return;
   }
-  log('warn', `${agentInfo?.name || agentId} didn't write learnings — no follow-up queued`);
+  // Info, not warn: not writing learnings is a soft signal (the agent finished
+  // and the engine continues fine). Operators don't need to act on it; keeping
+  // it at warn floods log.json (~50 entries/day) with non-actionable noise.
+  log('info', `${agentInfo?.name || agentId} didn't write learnings — no follow-up queued`);
 }
 
 function skillWriteTargets(runtimeName, project = null) {
@@ -3043,7 +3046,14 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
         }
       }
     } catch (err) {
-      log('warn', `Post-completion worktree cleanup error: ${err.message}`);
+      // ENOENT = worktree root doesn't exist yet (no worktrees ever created
+      // for this project, or already cleaned up). That's not a failure — there
+      // is simply nothing to clean. Other errors still warn.
+      if (err && err.code === 'ENOENT') {
+        log('debug', `Post-completion worktree cleanup: no worktree root yet (${err.message})`);
+      } else {
+        log('warn', `Post-completion worktree cleanup error: ${err.message}`);
+      }
     }
   }
 

package/engine/meeting.js

@@ -33,6 +33,18 @@ function isTerminalMeetingStatus(status) {
   return TERMINAL_MEETING_STATUSES.has(String(status || '').toLowerCase());
 }
 
+// Process-scoped dedup so a stuck meeting (missing agenda) logs the warning
+// once per id rather than every tick (~1/min). Module-scoped lifetime is
+// intentional: a fresh process should re-warn at startup so the operator sees
+// the issue, but the same engine run shouldn't spam.
+const _warnedMissingAgendaIds = new Set();
+function _warnOnceMissingAgenda(meetingId) {
+  if (!meetingId || _warnedMissingAgendaIds.has(meetingId)) return;
+  _warnedMissingAgendaIds.add(meetingId);
+  log('warn', `Meeting ${meetingId}: skipping discovery — agenda is missing or empty (will not be re-logged this process)`);
+}
+function _resetMissingAgendaWarnings() { _warnedMissingAgendaIds.clear(); }
+
 function expectedMeetingStatusForRound(roundName) {
   return ROUND_STATUS_BY_NAME[String(roundName || '').toLowerCase()] || null;
 }
@@ -445,6 +457,16 @@ function discoverMeetingWork(config) {
     if (!ACTIVE_MEETING_STATUSES.has(roundName)) continue;
     const agents = config.agents || {};
 
+    // Pre-flight validation: meetings missing required template vars (agenda)
+    // would otherwise fail playbook rendering on every tick (~1/min), spamming
+    // log.json with the same "missing required template variables: agenda"
+    // error. Skip them silently here; emit one structured warning per meeting
+    // ID per process so the operator still has signal without the spam.
+    if (!meeting.agenda || !String(meeting.agenda).trim()) {
+      _warnOnceMissingAgenda(meeting.id);
+      continue;
+    }
+
     if (roundName === 'concluding') {
       // Only one agent should conclude — skip if already concluded or any conclude dispatch is active
       if (meeting.conclusion) continue;
@@ -902,4 +924,5 @@ module.exports = {
   collectMeetingTakeaways,
   collectMeetingNextSteps,
   buildTimedOutMeetingConclusion,
+  _resetMissingAgendaWarnings, // exported for testing only
 };

package/engine/shared.js

@@ -128,6 +128,18 @@ function log(level, msg, meta = {}) {
   // Console output remains immediate (also redacted)
   console.log(`[${logTs()}] [${level}] ${safeMsg}`);
 
+  // Capture the resolved log file path AT WRITE TIME (not flush time).
+  // Stops test pollution: a test sets MINIONS_TEST_DIR, calls log(), the test
+  // ends and clears MINIONS_TEST_DIR, then the buffer flushes — without
+  // capture-at-write-time the entry would land in the production log.json.
+  // Stripped before persisting (see _flushLogBuffer).
+  Object.defineProperty(entry, '_logPath', {
+    value: _currentLogPath(),
+    enumerable: false,
+    writable: true,
+    configurable: true,
+  });
+
   _logBuffer.push(entry);
 
   // Start the flush timer lazily on first buffered entry
@@ -167,17 +179,33 @@ function _currentLogPath() {
 
 function _flushLogBuffer() {
   if (_logBuffer.length === 0) return;
-  // SEC-09 defense-in-depth: redact again at flush time so any direct
-  // `_logBuffer.push(entry)` callers (tests, future paths) can't leak secrets.
-  const entries = _logBuffer.splice(0).map(redactSecrets);
-  try {
-    mutateJsonFileLocked(_currentLogPath(), (logData) => {
-      if (!Array.isArray(logData)) logData = logData?.entries || [];
-      logData.push(...entries);
-      if (logData.length >= 2500) logData.splice(0, logData.length - 2000);
-      return logData;
-    }, { defaultValue: [] });
-  } catch { /* logging should never crash the caller */ }
+  const drained = _logBuffer.splice(0);
+  // Group entries by their captured _logPath so test-originated entries always
+  // land in the test dir's log.json even if MINIONS_TEST_DIR has been cleared
+  // by the time we flush. Entries without _logPath fall back to current path
+  // (eg. direct _logBuffer.push() from tests).
+  const fallbackPath = _currentLogPath();
+  const byPath = new Map();
+  for (const raw of drained) {
+    const target = raw._logPath || fallbackPath;
+    // SEC-09 defense-in-depth: redact again at flush time so any direct
+    // `_logBuffer.push(entry)` callers (tests, future paths) can't leak secrets.
+    const entry = redactSecrets(raw);
+    // Strip the routing-only metadata before persisting.
+    delete entry._logPath;
+    if (!byPath.has(target)) byPath.set(target, []);
+    byPath.get(target).push(entry);
+  }
+  for (const [target, entries] of byPath) {
+    try {
+      mutateJsonFileLocked(target, (logData) => {
+        if (!Array.isArray(logData)) logData = logData?.entries || [];
+        logData.push(...entries);
+        if (logData.length >= 2500) logData.splice(0, logData.length - 2000);
+        return logData;
+      }, { defaultValue: [] });
+    } catch { /* logging should never crash the caller */ }
+  }
 }
 
 /** Flush buffered log entries to disk. Call during graceful shutdown to drain the buffer. */
@@ -2877,7 +2905,10 @@ function createThrottleTracker({ label, baseBackoffMs = 60000, maxBackoffMs = 32
     const waitMs = (retryAfterMs > 0) ? retryAfterMs : state.backoffMs;
     state.throttled = true;
     state.retryAfter = Date.now() + waitMs;
-    log('warn', `[${label}] Throttled — retry after ${Math.round(waitMs / 1000)}s, consecutive hits: ${state.consecutiveHits}`);
+    // Throttle retries are deterministic backoff math — info, not warn.
+    // Operator already sees rate-limit signals via the underlying API errors
+    // upstream (which still log at warn). The retry-after restate is housekeeping.
+    log('info', `[${label}] Throttled — retry after ${Math.round(waitMs / 1000)}s, consecutive hits: ${state.consecutiveHits}`);
   }
 
   function recordSuccess() {

package/engine.js

@@ -1094,10 +1094,17 @@ async function spawnAgent(dispatchItem, config) {
 
   let proc;
   try {
+    // `detached: true` puts the agent in its own process group (POSIX) / job
+    // object (Windows), so when the engine dies — gracefully via stop, abruptly
+    // via taskkill, or because of a crash — the agent keeps running and can be
+    // re-attached on next start via PID file + live-output.log. We do NOT call
+    // proc.unref(): the engine still tracks exit while it's alive; detached
+    // only kicks in when the engine itself goes away.
     proc = runFile(process.execPath, spawnArgs, {
       cwd,
       stdio: ['pipe', 'pipe', 'pipe'],
       env: childEnv,
+      detached: true,
     });
   } catch (spawnErr) {
     // Synchronous spawn failure — record it to the (already-stamped) log so the
@@ -1308,10 +1315,12 @@ async function spawnAgent(dispatchItem, config) {
       }
       let resumeProc;
       try {
+        // detached so the resumed steering session also survives engine death (matches initial spawn)
         resumeProc = runFile(process.execPath, [spawnScript, steerPromptPath, sysPromptPath, ...resumeArgs], {
           cwd,
           stdio: ['pipe', 'pipe', 'pipe'],
           env: childEnv,
+          detached: true,
         });
       } catch (e) {
         log('warn', `Steering: spawn failed for ${agentId}: ${e.message}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.1761",
+  "version": "0.1.1763",
   "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"