@yemi33/minions 0.1.1915 → 0.1.1916

package/dashboard/js/render-prs.js

@@ -10,12 +10,11 @@ function prRow(pr) {
   // If PR is merged/abandoned, treat 'waiting' review as resolved
   const effectiveReviewStatus = (pr.status === 'merged' || pr.status === 'abandoned') && pr.reviewStatus === 'waiting' ? (pr.status === 'merged' ? 'approved' : 'pending') : pr.reviewStatus;
   const reviewSource = sq.status || effectiveReviewStatus || 'pending';
-  const reviewEscalated = !!pr._evalEscalated;
-  const reviewClass = reviewEscalated ? 'review-escalated' : reviewSource === 'approved' ? 'approved' : (reviewSource === 'changes-requested' || reviewSource === 'rejected') ? 'rejected' : reviewSource === 'waiting' ? 'building' : 'draft';
-  const reviewLabel = reviewEscalated ? 'review loop escalated (build/conflict may still run)' : sq.status === 'waiting' ? 'reviewing (minions)' : sq.status ? sq.status + ' (minions)' : (effectiveReviewStatus || 'pending');
-  const reviewTitle = reviewEscalated ? 'Review/re-review and review-fix automation stopped after evalMaxIterations; build-fix and conflict-fix automation may still run.' : '';
-  const buildClass = pr.buildFixEscalated ? 'build-escalated' : pr._buildStatusStale ? 'build-stale' : pr.buildStatus === 'passing' ? 'build-pass' : pr.buildStatus === 'failing' ? 'build-fail' : pr.buildStatus === 'running' ? 'building' : 'no-build';
-  const buildLabel = pr.buildFixEscalated ? 'escalated (' + (pr.buildFixAttempts || '?') + ' fixes)' : (pr.buildStatus || 'none') + (pr._buildStatusStale ? ' (stale)' : '');
+  const reviewClass = reviewSource === 'approved' ? 'approved' : (reviewSource === 'changes-requested' || reviewSource === 'rejected') ? 'rejected' : reviewSource === 'waiting' ? 'building' : 'draft';
+  const reviewLabel = sq.status === 'waiting' ? 'reviewing (minions)' : sq.status ? sq.status + ' (minions)' : (effectiveReviewStatus || 'pending');
+  const reviewTitle = '';
+  const buildClass = pr._buildStatusStale ? 'build-stale' : pr.buildStatus === 'passing' ? 'build-pass' : pr.buildStatus === 'failing' ? 'build-fail' : pr.buildStatus === 'running' ? 'building' : 'no-build';
+  const buildLabel = (pr.buildStatus || 'none') + (pr._buildStatusStale ? ' (stale)' : '');
   const buildTitle = pr._buildStatusDetail || '';
   const statusClass = pr.status === 'merged' ? 'merged' : pr.status === 'abandoned' ? 'rejected' : pr.status === 'active' ? 'active' : 'draft';
   const statusLabel = pr.status || 'active';

package/dashboard/js/settings.js

@@ -97,6 +97,7 @@ async function openSettings() {
       settingsToggle('Allow Temp Agents', 'set-allowTempAgents', !!e.allowTempAgents, 'Spawn ephemeral agents when all permanent agents are busy') +
       settingsToggle('Auto-archive Plans', 'set-autoArchive', !!e.autoArchive, 'Automatically archive plans after verify completes (off = manual archive via dashboard)') +
       settingsToggle('Auto-complete PRs', 'set-autoCompletePrs', !!e.autoCompletePrs, 'Auto-merge PRs when builds pass and review is approved (opt-in)') +
+      settingsToggle('CC Worker Pool', 'set-ccUseWorkerPool', !!e.ccUseWorkerPool, 'Route Command Center / doc-chat through a persistent copilot --acp worker per tab instead of spawning a fresh CLI per turn (opt-in)') +
     '</div>' +
 
     '<h3 style="font-size:13px;color:var(--blue);margin-bottom:8px">PR Polling &amp; Dispatch Gates</h3>' +
@@ -121,9 +122,7 @@ async function openSettings() {
 
     '<h3 style="font-size:13px;color:var(--blue);margin-bottom:8px">Limits &amp; Thresholds</h3>' +
     '<div style="display:grid;grid-template-columns:1fr 1fr;gap:8px;margin-bottom:16px">' +
-      settingsField('Eval Max Iterations', 'set-evalMaxIterations', e.evalMaxIterations || 3, '', 'Max review→fix cycles before escalating (1-10)') +
       settingsField('Eval Max Cost', 'set-evalMaxCost', e.evalMaxCost === null || e.evalMaxCost === undefined ? '' : e.evalMaxCost, '$', 'USD ceiling per work item across all eval iterations (blank = no limit)') +
-      settingsField('Max Build Fix Attempts', 'set-maxBuildFixAttempts', e.maxBuildFixAttempts || 3, '', 'Max auto-fix dispatches per PR before escalating to human (1-10)') +
       settingsField('Agent Busy Reassign', 'set-agentBusyReassignMs', e.agentBusyReassignMs || 600000, 'ms', 'Reassign work to another agent after it waits this long on a busy agent') +
       settingsField('Version Check Interval', 'set-versionCheckInterval', e.versionCheckInterval || 3600000, 'ms', 'How often to check npm for updates (default: 1 hour)') +
       settingsField('Ignored Comment Authors', 'set-ignoredCommentAuthors', (e.ignoredCommentAuthors || []).join(', '), '', 'Comma-separated usernames — comments auto-closed, never trigger fixes') +
@@ -230,7 +229,6 @@ async function openSettings() {
           settingsToggle('Copilot: suppress AGENTS.md', 'set-copilotSuppressAgentsMd', e.copilotSuppressAgentsMd !== false, '--no-custom-instructions: stops AGENTS.md auto-load from fighting Minions playbook prompts') +
           settingsToggle('Copilot: reasoning summaries', 'set-copilotReasoningSummaries', !!e.copilotReasoningSummaries, '--enable-reasoning-summaries (Anthropic-family models only)') +
           settingsToggle('Disable model discovery', 'set-disableModelDiscovery', !!e.disableModelDiscovery, 'Skip /api/runtimes/<name>/models REST calls fleet-wide. Settings UI falls back to free-text.') +
-          settingsToggle('Use persistent Copilot worker pool (faster CC responses)', 'set-ccUseWorkerPool', !!e.ccUseWorkerPool, 'Experimental — sub-task C of W-mp2w003600196c51 (CC perf). When ON, Command Center routes through engine/cc-worker-pool.js (one persistent `copilot --acp` process per CC tab) instead of spawning a fresh CLI per turn. Saves ~14s of cold-start cost on warm follow-up turns. Engine/agent dispatch path is unchanged. Off by default.') +
         '</div>' +
         '<div style="display:grid;grid-template-columns:1fr 3fr;gap:8px;margin-top:8px">' +
           '<div>' +
@@ -601,13 +599,12 @@ async function saveSettings() {
       autoFixReviewFeedback: document.getElementById('set-autoFixReviewFeedback').checked,
       autoFixHumanComments: document.getElementById('set-autoFixHumanComments').checked,
       autoCompletePrs: document.getElementById('set-autoCompletePrs').checked,
+      ccUseWorkerPool: !!document.getElementById('set-ccUseWorkerPool')?.checked,
       adoPollEnabled: document.getElementById('set-adoPollEnabled').checked,
       ghPollEnabled: document.getElementById('set-ghPollEnabled').checked,
       prPollStatusEvery: document.getElementById('set-prPollStatusEvery').value,
       prPollCommentsEvery: document.getElementById('set-prPollCommentsEvery').value,
-      evalMaxIterations: document.getElementById('set-evalMaxIterations').value,
       evalMaxCost: document.getElementById('set-evalMaxCost').value || null,
-      maxBuildFixAttempts: document.getElementById('set-maxBuildFixAttempts').value,
       agentBusyReassignMs: document.getElementById('set-agentBusyReassignMs').value,
       ignoredCommentAuthors: document.getElementById('set-ignoredCommentAuthors').value,
       versionCheckInterval: document.getElementById('set-versionCheckInterval').value,
@@ -626,7 +623,6 @@ async function saveSettings() {
       copilotReasoningSummaries: !!document.getElementById('set-copilotReasoningSummaries')?.checked,
       maxBudgetUsd: (document.getElementById('set-maxBudgetUsd')?.value ?? '').trim(),
       disableModelDiscovery: !!document.getElementById('set-disableModelDiscovery')?.checked,
-      ccUseWorkerPool: !!document.getElementById('set-ccUseWorkerPool')?.checked,
       maxTurnsByType: (function() {
         var mbt = {};
         var types = ['explore', 'ask', 'review', 'implement', 'fix', 'test', 'verify', 'plan', 'decompose'];

package/dashboard.js

@@ -7941,32 +7941,44 @@ What would you like to discuss or change? When you're happy, say "approve" and I
 
   const pathname = req.url.split('?')[0];
   const _reqStart = Date.now();
+  // Wrap handler invocations so a thrown rejection never leaves the socket
+  // half-open. Pre-fix, an async handler that threw after writeHead (or before
+  // it could finalize) would leave the response without an end(), parking the
+  // socket in CLOSE_WAIT on the server side indefinitely. Observed in the wild:
+  // 150+ CLOSE_WAIT sockets pinned to port 7331 on a live dashboard.
+  const _logIfApi = () => {
+    if (pathname.startsWith('/api/') && !pathname.includes('/status') && !pathname.includes('/hot-reload') && !pathname.includes('/status-stream') && !pathname.includes('/browser-presence')) {
+      console.log(`  ${req.method} ${pathname} ${Date.now() - _reqStart}ms`);
+    }
+  };
+  const _runHandler = async (handler, matchArg) => {
+    try {
+      const _result = await handler(req, res, matchArg);
+      _logIfApi();
+      return _result;
+    } catch (err) {
+      console.error(`  ${req.method} ${pathname} handler error:`, err && err.stack || err);
+      _logIfApi();
+      try {
+        if (!res.headersSent) jsonReply(res, 500, { error: 'Internal server error' }, req);
+        else if (!res.writableEnded) res.end();
+      } catch { /* socket may already be torn down */ }
+    }
+  };
   for (const route of ROUTES) {
     if (route.method !== req.method) continue;
     if (typeof route.path === 'string') {
       // For /api/skill, match with query string prefix since it has no fixed path variant
       if (route.path === '/api/skill') {
         if (!req.url.startsWith('/api/skill?') && req.url !== '/api/skill') continue;
-        const _result = await route.handler(req, res, {});
-        if (pathname.startsWith('/api/') && !pathname.includes('/status') && !pathname.includes('/hot-reload') && !pathname.includes('/status-stream') && !pathname.includes('/browser-presence')) {
-          console.log(`  ${req.method} ${pathname} ${Date.now() - _reqStart}ms`);
-        }
-        return _result;
+        return _runHandler(route.handler, {});
       }
       if (pathname !== route.path) continue;
-      const _result = await route.handler(req, res, {});
-      if (pathname.startsWith('/api/') && !pathname.includes('/status') && !pathname.includes('/hot-reload') && !pathname.includes('/status-stream') && !pathname.includes('/browser-presence')) {
-        console.log(`  ${req.method} ${pathname} ${Date.now() - _reqStart}ms`);
-      }
-      return _result;
+      return _runHandler(route.handler, {});
     }
     const m = pathname.match(route.path);
     if (m) {
-      const _result = await route.handler(req, res, m);
-      if (pathname.startsWith('/api/') && !pathname.includes('/status') && !pathname.includes('/hot-reload') && !pathname.includes('/status-stream') && !pathname.includes('/browser-presence')) {
-        console.log(`  ${req.method} ${pathname} ${Date.now() - _reqStart}ms`);
-      }
-      return _result;
+      return _runHandler(route.handler, m);
     }
   }
 

package/engine/cleanup.js

@@ -659,6 +659,52 @@ async function runCleanup(config, verbose = false) {
     }
   } catch (e) { log('warn', 'cleanup zombie processes: ' + e.message); }
 
+  // 4b. Sweep stray MCP descendants. Spawn-agent.js reaps its descendants on
+  // close, but a hard kill (engine restart, OS crash) can skip that path and
+  // leave orphan node.exe processes running MCP servers (Azure, Playwright,
+  // Loop, etc.) reparented away from the Minions tree. This sweep walks
+  // descendants from every anchor we know (engine, dashboard, active spawn-
+  // agents) and kills any node MCP processes outside that set.
+  cleaned.strayMcps = 0;
+  try {
+    const allProcs = shared.listAllProcesses();
+    if (allProcs.length) {
+      const anchorPids = [process.pid];
+      for (const info of activeProcesses.values()) {
+        if (info?.proc?.pid) anchorPids.push(info.proc.pid);
+      }
+      // Dashboard runs as a sibling process (not parented to engine on Windows)
+      // and hosts Command Center + doc-chat sessions whose Claude CLI children
+      // spawn their own MCP servers. Without anchoring it, the sweep would
+      // classify those MCP grandchildren as stray and kill live CC state on
+      // every cleanup tick. control.json doesn't carry a dashboardPid field,
+      // so we anchor by scanning the snapshot we already have for any node
+      // running dashboard.js.
+      for (const p of allProcs) {
+        if (p.cmd && /[\\/]dashboard\.js(?![\w.-])/i.test(p.cmd)) anchorPids.push(p.pid);
+      }
+      const reach = shared.listProcessReachable(anchorPids, allProcs);
+      // MCP server commandlines. Matches scoped (@modelcontextprotocol/*,
+      // @<scope>/mcp[-*]) and flat (mcp-server-*, *-mcp-server,
+      // loop-mcp-server) package paths. Specifically does NOT match
+      // @github/copilot (the Copilot CLI itself) — that would false-positive
+      // and kill a user's interactive `copilot` in another terminal, since
+      // its parent chain has no Minions ancestor and so isn't in `reach`.
+      const mcpRe = /[\\/](?:@modelcontextprotocol[\\/]|@[\w.-]+[\\/]mcp(?:[\\/]|-[\w-]*[\\/])|mcp-server-[\w-]+|[\w-]+-mcp-server|(?:ms-)?loop-mcp-server)[\\/]?/i;
+      const strayPids = [];
+      for (const p of allProcs) {
+        if (!p.cmd || !/node(?:\.exe)?\b/i.test(p.name)) continue;
+        if (!mcpRe.test(p.cmd)) continue;
+        if (reach.has(p.pid)) continue;
+        strayPids.push(p.pid);
+      }
+      if (strayPids.length) {
+        cleaned.strayMcps = shared.killByPidsImmediate(strayPids);
+        log('info', `Cleanup: ${cleaned.strayMcps}/${strayPids.length} stray MCP descendants reaped`);
+      }
+    }
+  } catch (e) { log('warn', 'cleanup stray MCPs: ' + e.message); }
+
   // 5. Clean spawn-debug.log
   try { fs.unlinkSync(path.join(ENGINE_DIR, 'spawn-debug.log')); } catch { /* cleanup */ }
 

package/engine/copilot-models.json

@@ -0,0 +1,5 @@
+{
+  "runtime": "copilot",
+  "models": null,
+  "cachedAt": "2026-05-13T21:49:07.029Z"
+}

package/engine/shared.js

@@ -3146,6 +3146,185 @@ function killImmediate(proc) {
   }
 }
 
+// Single-PID kill (no /T tree walk) — used by the orphan-MCP sweep where we
+// already enumerated descendants ourselves and the parent is dead, so /T would
+// be a no-op anyway.
+function killByPidImmediate(pid) {
+  const n = Number(pid);
+  if (!Number.isInteger(n) || n <= 0 || n === process.pid) return false;
+  if (process.platform === 'win32') {
+    try { _execSync(`taskkill /PID ${n} /F`, { stdio: 'pipe', timeout: 3000, windowsHide: true }); return true; }
+    catch { return false; }
+  }
+  try { process.kill(n, 'SIGKILL'); return true; } catch { return false; }
+}
+
+// Batched kill — one OS process for N PIDs. `taskkill` accepts repeated /PID
+// flags natively; on Unix we still loop process.kill, which is in-process and
+// cheap. Returns the count of successful kills.
+function killByPidsImmediate(pids) {
+  const valid = (Array.isArray(pids) ? pids : [])
+    .map(Number)
+    .filter(n => Number.isInteger(n) && n > 0 && n !== process.pid);
+  if (!valid.length) return 0;
+  if (process.platform === 'win32') {
+    const flags = valid.map(p => `/PID ${p}`).join(' ');
+    try { _execSync(`taskkill /F ${flags}`, { stdio: 'pipe', timeout: 5000, windowsHide: true }); return valid.length; }
+    catch {
+      let killed = 0;
+      for (const p of valid) { if (killByPidImmediate(p)) killed++; }
+      return killed;
+    }
+  }
+  let killed = 0;
+  for (const p of valid) {
+    try { process.kill(p, 'SIGKILL'); killed++; } catch { /* dead */ }
+  }
+  return killed;
+}
+
+// ─── Process Table Enumeration ───────────────────────────────────────────────
+// Cross-platform listing of every live process as { pid, ppid, name, cmd? }.
+// `cmd` is best-effort — included on Windows (via wmic) and Linux (/proc); may
+// be empty on macOS without ps -ww.
+
+function _parseWmicCsv(text) {
+  const lines = String(text || '').split(/\r?\n/).map(l => l.trim()).filter(Boolean);
+  if (lines.length < 2) return [];
+  const header = lines[0].split(',');
+  const idx = (col) => header.findIndex(h => h.toLowerCase() === col.toLowerCase());
+  const nameIdx = idx('Name');
+  const ppidIdx = idx('ParentProcessId');
+  const pidIdx = idx('ProcessId');
+  const cmdIdx = idx('CommandLine');
+  if (nameIdx < 0 || ppidIdx < 0 || pidIdx < 0) return [];
+  const out = [];
+  for (let i = 1; i < lines.length; i++) {
+    // CommandLine can contain commas — naive split is fine because Name + PIDs
+    // sit at fixed positions and CommandLine, when present, is the LAST column.
+    const cols = lines[i].split(',');
+    if (cols.length < 4) continue;
+    const pid = parseInt(cols[pidIdx], 10);
+    if (!Number.isInteger(pid) || pid <= 0) continue;
+    const ppid = parseInt(cols[ppidIdx], 10);
+    const name = cols[nameIdx] || '';
+    const cmd = cmdIdx >= 0 ? cols.slice(cmdIdx).join(',') : '';
+    out.push({ pid, ppid: Number.isInteger(ppid) ? ppid : 0, name, cmd });
+  }
+  return out;
+}
+
+// PowerShell Get-CimInstance is the modern path (wmic is removed on Win11
+// 24H2+). We try it first and fall back to wmic for older Windows hosts.
+function _psListProcesses() {
+  const script = "Get-CimInstance Win32_Process | Select-Object Name,ParentProcessId,ProcessId,CommandLine | ConvertTo-Json -Compress -Depth 2";
+  try {
+    const out = _execSync(
+      `powershell -NoProfile -NonInteractive -Command "${script}"`,
+      { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 4000, windowsHide: true, maxBuffer: 4 * 1024 * 1024 }
+    );
+    const parsed = JSON.parse(out);
+    const arr = Array.isArray(parsed) ? parsed : [parsed];
+    return arr.map(p => ({
+      pid: Number(p.ProcessId),
+      ppid: Number(p.ParentProcessId) || 0,
+      name: p.Name || '',
+      cmd: p.CommandLine || '',
+    })).filter(p => Number.isInteger(p.pid) && p.pid > 0);
+  } catch { return null; }
+}
+
+function _winListProcesses() {
+  const ps = _psListProcesses();
+  if (ps && ps.length) return ps;
+  try {
+    const out = _execSync(
+      'wmic process get Name,ParentProcessId,ProcessId,CommandLine /format:csv',
+      { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 4000, windowsHide: true, maxBuffer: 4 * 1024 * 1024 }
+    );
+    return _parseWmicCsv(out);
+  } catch { return []; }
+}
+
+function _unixListProcesses() {
+  try {
+    const out = _execSync(
+      'ps -A -o pid=,ppid=,comm=',
+      { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 5000 }
+    );
+    return out.split(/\r?\n/).map(line => {
+      const m = line.trim().match(/^(\d+)\s+(\d+)\s+(.*)$/);
+      if (!m) return null;
+      return { pid: parseInt(m[1], 10), ppid: parseInt(m[2], 10), name: m[3], cmd: '' };
+    }).filter(Boolean);
+  } catch { return []; }
+}
+
+function listAllProcesses() {
+  return process.platform === 'win32' ? _winListProcesses() : _unixListProcesses();
+}
+
+function _buildChildMap(processes) {
+  const childMap = new Map();
+  for (const p of processes) {
+    if (!childMap.has(p.ppid)) childMap.set(p.ppid, []);
+    childMap.get(p.ppid).push(p.pid);
+  }
+  return childMap;
+}
+
+// BFS descendants of rootPid given a process snapshot. `allProcesses` is
+// injectable for tests and for amortizing one snapshot across multiple
+// `listProcessDescendants` calls in the same tick.
+function listProcessDescendants(rootPid, allProcesses = null) {
+  const root = Number(rootPid);
+  if (!Number.isInteger(root) || root <= 0) return [];
+  const procs = Array.isArray(allProcesses) ? allProcesses : listAllProcesses();
+  const childMap = _buildChildMap(procs);
+  const result = [];
+  const seen = new Set([root]);
+  const queue = [root];
+  while (queue.length) {
+    const cur = queue.shift();
+    const children = childMap.get(cur) || [];
+    for (const c of children) {
+      if (seen.has(c)) continue;
+      seen.add(c);
+      result.push(c);
+      queue.push(c);
+    }
+  }
+  return result;
+}
+
+// Same BFS, but starts from any number of root PIDs and returns the full reach
+// set (including the roots themselves). Used by the orphan-MCP sweep to compute
+// "everything anchored to Minions" so non-anchored MCP node processes can be
+// identified.
+function listProcessReachable(rootPids, allProcesses = null) {
+  const roots = (Array.isArray(rootPids) ? rootPids : [rootPids])
+    .map(Number)
+    .filter(n => Number.isInteger(n) && n > 0);
+  if (!roots.length) return new Set();
+  const procs = Array.isArray(allProcesses) ? allProcesses : listAllProcesses();
+  const childMap = _buildChildMap(procs);
+  const seen = new Set();
+  const queue = [];
+  for (const r of roots) {
+    if (!seen.has(r)) { seen.add(r); queue.push(r); }
+  }
+  while (queue.length) {
+    const cur = queue.shift();
+    const children = childMap.get(cur) || [];
+    for (const c of children) {
+      if (seen.has(c)) continue;
+      seen.add(c);
+      queue.push(c);
+    }
+  }
+  return seen;
+}
+
 // ─── Work Items & Pull Requests Mutation Helpers ────────────────────────────
 
 /**
@@ -3604,6 +3783,11 @@ module.exports = {
   sleepMs,
   killGracefully,
   killImmediate,
+  killByPidImmediate,
+  killByPidsImmediate,
+  listAllProcesses,
+  listProcessDescendants,
+  listProcessReachable,
   removeWorktree,
   _purgeReservedFiles, // exported for testing
   _WIN_RESERVED_NAMES, // exported for testing

package/engine/spawn-agent.js

@@ -35,7 +35,7 @@
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
-const { runFile, cleanChildEnv, killGracefully, killImmediate, ts, resolveEngineCacheDir } = require('./shared');
+const { runFile, cleanChildEnv, killGracefully, killImmediate, killByPidsImmediate, listProcessDescendants, ts, resolveEngineCacheDir } = require('./shared');
 const { resolveRuntime } = require('./runtimes');
 const { acquireAdoTokenSync, isLikelyAdoToken } = require('./ado-token');
 
@@ -484,6 +484,32 @@ function main() {
   }, MCP_STARTUP_TIMEOUT);
   proc.stdout.once('data', () => { gotFirstOutput = true; clearTimeout(startupTimer); });
 
+  // Descendant snapshot loop (orphan-MCP fix). The runtime CLI (claude/copilot)
+  // spawns one node child per configured MCP server (Azure, Playwright, Loop,
+  // …). When the runtime exits normally on Windows, those grandchildren are
+  // reparented and survive indefinitely — they don't watch stdin for EOF, and
+  // taskkill /T against the dead parent PID no longer finds them. We snapshot
+  // the descendant tree periodically while the runtime is alive so the close
+  // handler can reap any survivors by PID after the parent has gone.
+  const trackedDescendants = new Set();
+  let snapshotInFlight = false;
+  function snapshotDescendants() {
+    if (!proc.pid || snapshotInFlight) return;
+    snapshotInFlight = true;
+    try {
+      for (const pid of listProcessDescendants(proc.pid)) trackedDescendants.add(pid);
+    } catch { /* best-effort */ }
+    finally { snapshotInFlight = false; }
+  }
+  // Initial snapshot is deferred: MCP children spawn ~1-3s after runtime boot,
+  // and a 0ms snapshot would always be empty. Recurring snapshots run every
+  // 30s — Get-CimInstance enumerates every process on the box, so anything
+  // hotter starves the cleanup tick with N concurrent agents.
+  const initialSnapshotTimer = setTimeout(snapshotDescendants, 3000);
+  if (initialSnapshotTimer.unref) initialSnapshotTimer.unref();
+  const descTimer = setInterval(snapshotDescendants, 30000);
+  if (descTimer.unref) descTimer.unref();
+
   // Track the real OS exit code via the 'exit' event. Node's 'close' event
   // can report code=0 on Windows when the OS-level exit was non-zero
   // (observed empirically with both Claude Code CLI and Copilot CLI exiting
@@ -500,6 +526,18 @@ function main() {
   });
   proc.on('close', (code, signal) => {
     clearTimeout(startupTimer);
+    clearTimeout(initialSnapshotTimer);
+    clearInterval(descTimer);
+    // Final snapshot + reap, but only when the runtime actually spawned
+    // children. Read-only / very short agents (exit before the 3s initial
+    // snapshot fires) skip the wmic shell-out entirely.
+    if (trackedDescendants.size || gotFirstOutput) {
+      snapshotDescendants();
+      if (trackedDescendants.size) {
+        const reaped = killByPidsImmediate([...trackedDescendants]);
+        try { fs.appendFileSync(debugPath, `DESCENDANTS reaped=${reaped}/${trackedDescendants.size}\n`); } catch {}
+      }
+    }
     // Prefer the 'exit' event's code/signal when present — see note above.
     const effectiveCode = (realExitFromEvent != null) ? realExitFromEvent : code;
     const effectiveSignal = realSignalFromEvent || signal;

package/package.json

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