@yemi33/minions 0.1.1058 → 0.1.1060

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## 0.1.1060 (2026-04-17)
+
+### Features
+- seed realActivityMap at spawn time, stamp pid in live-output (#1200)
+
+### Fixes
+- cap temp-agent creation at maxConcurrent per tick (#1219)
+-  reassign pending items from unspawned temp agents to idle named agents (#1204) (#1212)
+- guard undefined agent in pending dispatch loop (closes #1206) (#1210)
+-  improve fallback meeting conclusion
+-  remove command center chevron
+- stamp live-output.log stub before spawn (#1198)
+-  harden settings save and migrate pr poll config
+
+### Other
+- Use PAT for publish merges
+- test(queries): add unit tests for invalidateDispatchCache/getInbox/getAgentCharter (#1214)
+- test(shared): add unit tests for truncateTextBytes/tailTextBytes/execSilent/trackReviewMetric/parseCanonicalPrId (#1215)
+- Fix publish workflow merge
+- chore: raise default meeting round timeout
+- Harden prompt context handling
+- Harden loop watch conversion
+- Add watches sidebar activity badge
+- test(cli): add unit tests for handleCommand, start, stop, kill, spawn (#1191)
+- chore: untrack pipeline files — local config only
+- restore: recover daily-arch-improvement and weekly-dead-code-cleanup pipelines
+- Harden CC stream resilience
+
 ## 0.1.1058 (2026-04-17)
 
 ### Features

package/engine/routing.js

@@ -102,6 +102,20 @@ function isAgentIdle(agentId) {
 const _claimedAgents = new Set();
 function resetClaimedAgents() { _claimedAgents.clear(); }
 
+// Per-tick temp-agent creation budget. Defaults to Infinity (unbounded) so
+// routing.js in isolation keeps previous behaviour. The engine calls
+// setTempBudget() once per tick with `maxConcurrent - activeCount` to ensure
+// temp agents count against maxConcurrent exactly like named agents.
+// Without this, a batch discovery (e.g. PR-poll sweep over many failing PRs)
+// would register one temp agent per pending item, overwhelming the OS and
+// causing mass orphans when the dispatch loop spawns them on later ticks.
+// Closes #1209.
+let _tempBudget = Infinity;
+function setTempBudget(n) {
+  _tempBudget = (typeof n === 'number' && n >= 0 && Number.isFinite(n)) ? n : Infinity;
+}
+function getTempBudget() { return _tempBudget; }
+
 function resolveAgent(workType, config, authorAgent = null) {
   const routes = getRoutingTableCached();
   const route = routes[workType] || routes['implement'];
@@ -144,6 +158,16 @@ function resolveAgent(workType, config, authorAgent = null) {
 
   // No idle configured agent — try temp agent if enabled
   if (config.engine?.allowTempAgents) {
+    // Enforce per-tick temp-agent budget so temps count against maxConcurrent.
+    // Without this guard, a mass-discovery pass (e.g. 20 PR build failures) would
+    // register one temp agent per pending item regardless of concurrency cap,
+    // leaking orphan temp IDs into tempAgents/dispatch and, over subsequent ticks,
+    // spawning far more processes than maxConcurrent allows (#1209).
+    if (_tempBudget <= 0) {
+      log('info', `Temp agent refused for ${workType} — per-tick budget exhausted (maxConcurrent reached)`);
+      return null;
+    }
+    _tempBudget--;
     const tempId = `temp-${shared.uid()}`;
     _claimedAgents.add(tempId);
     tempAgents.set(tempId, { name: `Temp-${tempId.slice(5, 9)}`, role: 'Temporary Agent', createdAt: ts() });
@@ -166,4 +190,6 @@ module.exports = {
   _claimedAgents,
   resetClaimedAgents,
   resolveAgent,
+  setTempBudget,
+  getTempBudget,
 };

package/engine.js

@@ -122,7 +122,7 @@ const { getConfig, getControl, getDispatch, getNotes,
 
 const { getRouting, parseRoutingTable, getRoutingTableCached, getMonthlySpend,
   getAgentErrorRate, isAgentIdle, resolveAgent, resetClaimedAgents,
-  tempAgents } = require('./engine/routing');
+  setTempBudget, tempAgents } = require('./engine/routing');
 
 // ─── Playbook, system prompt, agent context (extracted to engine/playbook.js) ─
 
@@ -3434,6 +3434,18 @@ async function tickInner() {
   }
 
   // 3. Discover new work from sources
+  // Cap temp-agent creation at (maxConcurrent - activeCount) for this tick so
+  // temps count against maxConcurrent like named agents. Without this, a mass
+  // discovery pass (e.g. 20 PR build failures) would stamp a fresh temp agent
+  // onto every pending item regardless of concurrency cap, and those temps
+  // would spawn over subsequent ticks — overwhelming the OS and mass-orphaning
+  // the dispatches (#1209).
+  {
+    const dispatchPre = getDispatch();
+    const activeCountPre = (dispatchPre.active || []).length;
+    const maxC = config.engine?.maxConcurrent ?? ENGINE_DEFAULTS.maxConcurrent;
+    setTempBudget(Math.max(0, maxC - activeCountPre));
+  }
   let discoveryOk = true;
   try { await discoverWork(config); } catch (e) { log('warn', 'discoverWork: ' + e.message); discoveryOk = false; }
 

package/package.json

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