@yemi33/minions 0.1.1732 → 0.1.1733

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.1.1733 (2026-05-05)
+
+### Features
+-  dryRun resolveAgent, bounded mainBranch cache, SSE heartbeat helper
+
 ## 0.1.1732 (2026-05-05)
 
 ### Features

package/dashboard.js

@@ -472,6 +472,43 @@ let HTML = HTML_RAW;
 let HTML_GZ = zlib.gzipSync(HTML);
 let HTML_ETAG = '"' + require('crypto').createHash('md5').update(HTML).digest('hex') + '"';
 
+const SSE_CLIENT_HEARTBEAT_MS = 30000;
+const _sseClientCleanups = new WeakMap();
+function _removeSseClient(clientSet, res) {
+  const cleanup = _sseClientCleanups.get(res);
+  if (cleanup) cleanup();
+  else clientSet.delete(res);
+}
+
+function _trackSseClient(clientSet, req, res, { heartbeatMs = SSE_CLIENT_HEARTBEAT_MS } = {}) {
+  let closed = false;
+  let heartbeatTimer = null;
+  const cleanup = () => {
+    if (closed) return;
+    closed = true;
+    if (heartbeatTimer) clearInterval(heartbeatTimer);
+    heartbeatTimer = null;
+    clientSet.delete(res);
+    _sseClientCleanups.delete(res);
+  };
+  const heartbeat = () => {
+    if (res.destroyed || res.writableEnded) {
+      cleanup();
+      return;
+    }
+    try { res.write(': heartbeat\n\n'); } catch { cleanup(); }
+  };
+  heartbeatTimer = setInterval(heartbeat, heartbeatMs);
+  if (heartbeatTimer.unref) heartbeatTimer.unref();
+  _sseClientCleanups.set(res, cleanup);
+  clientSet.add(res);
+  req.on('close', cleanup);
+  req.on('aborted', cleanup);
+  res.on('close', cleanup);
+  res.on('error', cleanup);
+  return cleanup;
+}
+
 // Hot-reload: watch dashboard/ directory for changes, rebuild, and push reload to browsers
 const _hotReloadClients = new Set();
 
@@ -486,11 +523,11 @@ function rebuildDashboardHtml() {
     console.log('  Dashboard hot-reloaded');
     // Push reload to all connected browsers via status-stream (saves a connection)
     for (const res of _statusStreamClients) {
-      try { res.write('event: reload\ndata: reload\n\n'); } catch { _statusStreamClients.delete(res); }
+      try { res.write('event: reload\ndata: reload\n\n'); } catch { _removeSseClient(_statusStreamClients, res); }
     }
     // Legacy hot-reload clients
     for (const res of _hotReloadClients) {
-      try { res.write('data: reload\n\n'); } catch { _hotReloadClients.delete(res); }
+      try { res.write('data: reload\n\n'); } catch { _removeSseClient(_hotReloadClients, res); }
     }
   } catch (e) { console.error('  Hot-reload error:', e.message); }
 }
@@ -742,7 +779,7 @@ function invalidateStatusCache(opts) {
     if (_statusStreamClients.size === 0) return;
     const data = getStatusJson();
     for (const res of _statusStreamClients) {
-      try { res.write('data: ' + data + '\n\n'); } catch { _statusStreamClients.delete(res); }
+      try { res.write('data: ' + data + '\n\n'); } catch { _removeSseClient(_statusStreamClients, res); }
     }
   }, 500);
 }
@@ -874,7 +911,7 @@ setInterval(() => {
   if (data === _lastStatusPushRef) return; // O(1) reference comparison — new string ref means content changed
   _lastStatusPushRef = data;
   for (const res of _statusStreamClients) {
-    try { res.write('data: ' + data + '\n\n'); } catch { _statusStreamClients.delete(res); }
+    try { res.write('data: ' + data + '\n\n'); } catch { _removeSseClient(_statusStreamClients, res); }
   }
 }, 10000);
 
@@ -894,6 +931,7 @@ const CC_LOCK_WAIT_MS = 200; // grace period for previous handler's finally to r
 const CC_STREAM_HEARTBEAT_MS = 15000; // keep streaming responses alive across proxies/restart races
 const CC_STREAM_REATTACH_GRACE_MS = 60000; // keep CC job alive briefly after disconnect so the UI can reattach
 const CC_STREAM_DONE_RETENTION_MS = 30000; // retain final payload briefly so reconnect can still receive it
+const CC_LIVE_STREAM_MAX_AGE_MS = shared.ENGINE_DEFAULTS.ccLiveStreamMaxAgeMs;
 // Doc-chat is interactive — long-doc edits with multi-step Read+Write tool use can run
 // 4–5 min on `canEdit:true` paths. CC's default 2-min timeout was killing legitimate
 // edits mid-stream. Pinned to 6 min as the bounded but generous ceiling.
@@ -902,6 +940,9 @@ function _releaseCCTab(tabId) { ccInFlightTabs.delete(tabId); ccInFlightAborts.d
 function _getCcLiveStream(tabId) {
   return ccLiveStreams.get(tabId) || null;
 }
+function _touchCcLiveStream(state) {
+  if (state) state.updatedAt = Date.now();
+}
 function _clearCcLiveTimers(tabId) {
   const state = _getCcLiveStream(tabId);
   if (!state) return;
@@ -934,6 +975,8 @@ function _ensureCcLiveStream(tabId) {
     abortFn: null,
     abortTimer: null,
     cleanupTimer: null,
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
   };
   ccLiveStreams.set(tabId, state);
   return state;
@@ -943,6 +986,7 @@ function _attachCcLiveStream(tabId, writer, endResponse) {
   _clearCcLiveTimers(tabId);
   state.writer = writer;
   state.endResponse = endResponse;
+  _touchCcLiveStream(state);
   return state;
 }
 function _detachCcLiveStream(tabId, writer) {
@@ -961,7 +1005,9 @@ function _scheduleCcLiveAbort(tabId) {
     const live = _getCcLiveStream(tabId);
     if (!live || live.donePayload || live.writer) return;
     try { if (live.abortFn) live.abortFn(); } catch {}
+    _scheduleCcLiveCleanup(tabId, CC_STREAM_REATTACH_GRACE_MS);
   }, CC_STREAM_REATTACH_GRACE_MS);
+  if (state.abortTimer.unref) state.abortTimer.unref();
 }
 function _scheduleCcLiveCleanup(tabId, delayMs = CC_STREAM_DONE_RETENTION_MS) {
   const state = _getCcLiveStream(tabId);
@@ -972,7 +1018,25 @@ function _scheduleCcLiveCleanup(tabId, delayMs = CC_STREAM_DONE_RETENTION_MS) {
     if (!live || live.writer) return;
     _clearCcLiveStream(tabId);
   }, delayMs);
+  if (state.cleanupTimer.unref) state.cleanupTimer.unref();
+}
+function _sweepCcLiveStreams() {
+  const now = Date.now();
+  for (const [tabId, state] of ccLiveStreams.entries()) {
+    const age = now - (state.updatedAt || state.createdAt || now);
+    if (state.donePayload && !state.writer && age > CC_STREAM_DONE_RETENTION_MS) {
+      _clearCcLiveStream(tabId);
+      continue;
+    }
+    if (age <= CC_LIVE_STREAM_MAX_AGE_MS) continue;
+    try { if (state.abortFn) state.abortFn(); } catch {}
+    try { if (state.endResponse) state.endResponse(); } catch {}
+    _releaseCCTab(tabId);
+    _clearCcLiveStream(tabId);
+  }
 }
+const _ccLiveSweepTimer = setInterval(_sweepCcLiveStreams, Math.min(CC_LIVE_STREAM_MAX_AGE_MS, 5 * 60 * 1000));
+if (_ccLiveSweepTimer.unref) _ccLiveSweepTimer.unref();
 function _ccTabIsInFlight(tabId) {
   if (!ccInFlightTabs.has(tabId)) return false;
   // Auto-release stale locks — if a request has been in-flight longer than CC_INFLIGHT_TIMEOUT_MS,
@@ -1797,7 +1861,7 @@ async function executeCCActions(actions) {
           // Pre-flight routing check: warn the user if no agent is currently available so the new
           // item won't sit pending invisibly. Routing failure is non-fatal — the WI was created.
           try {
-            const resolvedAgent = routing.resolveAgent(workType, CONFIG, { agentHints });
+            const resolvedAgent = routing.resolveAgent(workType, CONFIG, { agentHints, dryRun: true });
             if (!resolvedAgent) {
               const lastResult = results[results.length - 1];
               lastResult.warning = `Created ${id} but no agent is currently available to dispatch (routing returned no match for workType=${workType}${agentHints.length ? ', hints=' + agentHints.join(',') : ''}). Item will sit pending until an agent becomes available.`;
@@ -1841,12 +1905,20 @@ async function executeCCActions(actions) {
             project_path: project.localPath || '',
             task: `Build & test ${pr.id}: ${pr.title || ''}`,
           }, `Build & test ${pr.id}: ${pr.title || ''}`,
-          { dispatchKey, source: 'cc-build-and-test', pr, branch: pr.branch, project: { name: project.name, localPath: project.localPath } });
+           { dispatchKey, source: 'cc-build-and-test', pr, branch: pr.branch, project: { name: project.name, localPath: project.localPath } });
           if (!item) {
+            if (agentId?.startsWith('temp-')) {
+              routing.tempAgents.delete(agentId);
+              routing._claimedAgents.delete(agentId);
+            }
             results.push({ type: 'build-and-test', error: 'Failed to render build-and-test playbook' });
             break;
           }
           const id = dispatchMod.addToDispatch(item);
+          if (agentId?.startsWith('temp-')) {
+            routing.tempAgents.delete(agentId);
+            routing._claimedAgents.delete(agentId);
+          }
           results.push({ type: 'build-and-test', id, agent: agentId, pr: pr.id, ok: true });
           break;
         }
@@ -1975,8 +2047,36 @@ async function executeDocChatActions(actions) {
 const CC_SESSIONS_PATH = path.join(ENGINE_DIR, 'cc-sessions.json');
 const DOC_SESSIONS_PATH = path.join(ENGINE_DIR, 'doc-sessions.json');
 const DOC_SESSION_TTL_MS = shared.ENGINE_DEFAULTS.docSessionTtlMs;
+const DOC_SESSION_MAX_ENTRIES = shared.ENGINE_DEFAULTS.docSessionMaxEntries;
 const docSessions = new Map(); // key → { sessionId, lastActiveAt, turnCount }
 
+function _docSessionLastActiveMs(session) {
+  const ms = Date.parse(session?.lastActiveAt || session?.createdAt || '');
+  return Number.isFinite(ms) ? ms : 0;
+}
+
+function pruneDocSessions() {
+  let changed = false;
+  for (const [key, s] of docSessions.entries()) {
+    if (!s || (s.turnCount || 0) >= CC_SESSION_MAX_TURNS ||
+        _sessionExpired(s.lastActiveAt || s.createdAt, DOC_SESSION_TTL_MS) ||
+        s._promptHash !== _docChatPromptHash) {
+      docSessions.delete(key);
+      changed = true;
+    }
+  }
+  const maxEntries = Number(DOC_SESSION_MAX_ENTRIES) > 0 ? Number(DOC_SESSION_MAX_ENTRIES) : 200;
+  if (docSessions.size > maxEntries) {
+    const oldest = Array.from(docSessions.entries())
+      .sort((a, b) => _docSessionLastActiveMs(a[1]) - _docSessionLastActiveMs(b[1]));
+    for (const [key] of oldest.slice(0, docSessions.size - maxEntries)) {
+      docSessions.delete(key);
+      changed = true;
+    }
+  }
+  return changed;
+}
+
 // Load persisted doc sessions on startup
 try {
   const saved = safeJson(DOC_SESSIONS_PATH);
@@ -1986,15 +2086,22 @@ try {
       if (_sessionExpired(s.lastActiveAt || s.createdAt, DOC_SESSION_TTL_MS)) continue;
       docSessions.set(key, s);
     }
+    pruneDocSessions();
   }
 } catch { /* optional */ }
 
 function persistDocSessions() {
+  pruneDocSessions();
   const obj = {};
   for (const [key, s] of docSessions) obj[key] = s;
   safeWrite(DOC_SESSIONS_PATH, obj);
 }
 
+const _docSessionPruneTimer = setInterval(() => {
+  if (pruneDocSessions()) persistDocSessions();
+}, Math.min(DOC_SESSION_TTL_MS, 60 * 60 * 1000));
+if (_docSessionPruneTimer.unref) _docSessionPruneTimer.unref();
+
 // Debounced variant — coalesces rapid writes (e.g. back-to-back doc-chat turns)
 let _persistDocSessionsTimer = null;
 function schedulePersistDocSessions() {
@@ -2062,6 +2169,7 @@ function updateSession(store, key, sessionId, existing) {
       _docHash: prev?._docHash || null,
       _promptHash: _docChatPromptHash,
     });
+    pruneDocSessions();
     schedulePersistDocSessions();
   }
 }
@@ -5255,6 +5363,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       sessionId, effort, direct: true,
       engineConfig,
       onChunk: (text) => {
+        _touchCcLiveStream(liveState);
         const display = stripCCActionsForStream(text);
         liveState.text = display;
         // Once text is flowing, the SSE-replay branch (live.thinkingSent &&
@@ -5263,11 +5372,13 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         if (liveState.writer) liveState.writer({ type: 'chunk', text: display });
       },
       onToolUse: (name, input) => {
+        _touchCcLiveStream(liveState);
         toolUses.push({ name, input: input || {} });
         liveState.tools.push({ name, input: input || {} });
         if (liveState.writer) liveState.writer({ type: 'tool', name, input: _lightToolInput(input) });
       },
       onThinking: () => {
+        _touchCcLiveStream(liveState);
         liveState.thinkingSent = true;
         if (liveState.writer) liveState.writer({ type: 'thinking', text: 'Thinking...' });
       },
@@ -6318,15 +6429,13 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     { method: 'GET', path: '/api/status-stream', desc: 'SSE stream of real-time status updates', handler: (req, res) => {
       res.writeHead(200, { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', 'Connection': 'keep-alive' });
       res.write('data: ' + getStatusJson() + '\n\n');
-      _statusStreamClients.add(res);
-      req.on('close', () => _statusStreamClients.delete(res));
+      _trackSseClient(_statusStreamClients, req, res);
     }},
     { method: 'GET', path: '/api/health', desc: 'Lightweight health check for monitoring', handler: handleHealth },
     { method: 'GET', path: '/api/hot-reload', desc: 'SSE stream for dashboard hot-reload notifications', handler: (req, res) => {
       res.writeHead(200, { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', 'Connection': 'keep-alive' });
       res.write('data: connected\n\n');
-      _hotReloadClients.add(res);
-      req.on('close', () => _hotReloadClients.delete(res));
+      _trackSseClient(_hotReloadClients, req, res);
     }},
 
     // Work items

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-05-05T09:53:42.976Z"
+  "cachedAt": "2026-05-05T20:52:36.454Z"
 }

package/engine/routing.js

@@ -190,7 +190,7 @@ function normalizeAgentHints(agentHints, authorAgent = null, agents = null) {
 }
 
 function resolveAgent(workType, config, opts = {}) {
-  const { authorAgent = null, agentHints = null } = opts || {};
+  const { authorAgent = null, agentHints = null, dryRun = false } = opts || {};
   const route = routeForWorkType(workType);
   const agents = config.agents || {};
 
@@ -199,7 +199,7 @@ function resolveAgent(workType, config, opts = {}) {
   let fallback = route.fallback === '_author_' ? authorAgent : route.fallback;
 
   const isAvailable = (id) => {
-    if (!agents[id] || !isAgentIdle(id) || _claimedAgents.has(id)) return false;
+    if (!agents[id] || !isAgentIdle(id) || (!dryRun && _claimedAgents.has(id))) return false;
     // Budget check — no budget means infinite (no limit)
     const budget = agents[id].monthlyBudgetUsd;
     if (budget && budget > 0) {
@@ -214,23 +214,23 @@ function resolveAgent(workType, config, opts = {}) {
     const idle = Object.keys(agents)
       .filter(id => !excludeSet.has(id) && isAvailable(id))
       .sort((a, b) => getAgentErrorRate(a) - getAgentErrorRate(b));
-    if (idle[0]) { _claimedAgents.add(idle[0]); return idle[0]; }
+    if (idle[0]) { if (!dryRun) _claimedAgents.add(idle[0]); return idle[0]; }
     return null;
   };
 
   const hintedAgents = normalizeAgentHints(agentHints, authorAgent, agents);
   if (hintedAgents.length > 0) {
     for (const id of hintedAgents) {
-      if (isAvailable(id)) { _claimedAgents.add(id); return id; }
+      if (isAvailable(id)) { if (!dryRun) _claimedAgents.add(id); return id; }
     }
   }
 
   // Resolve _any_ token — pick any available agent (#480)
   if (preferred === ANY_AGENT) { const pick = pickAnyIdle(); if (pick) return pick; }
-  else if (preferred && isAvailable(preferred)) { _claimedAgents.add(preferred); return preferred; }
+  else if (preferred && isAvailable(preferred)) { if (!dryRun) _claimedAgents.add(preferred); return preferred; }
 
   if (fallback === ANY_AGENT) { const pick = pickAnyIdle([preferred]); if (pick) return pick; }
-  else if (fallback && isAvailable(fallback)) { _claimedAgents.add(fallback); return fallback; }
+  else if (fallback && isAvailable(fallback)) { if (!dryRun) _claimedAgents.add(fallback); return fallback; }
 
   // Fall back to any idle agent, preferring lower error rates
   const anyIdle = pickAnyIdle([preferred, fallback]);
@@ -247,6 +247,7 @@ function resolveAgent(workType, config, opts = {}) {
       log('info', `Temp agent refused for ${workType} — per-tick budget exhausted (maxConcurrent reached)`);
       return null;
     }
+    if (dryRun) return 'temp-preview';
     _tempBudget--;
     const tempId = `temp-${shared.uid()}`;
     _claimedAgents.add(tempId);

package/engine/shared.js

@@ -684,10 +684,34 @@ function execAsync(cmd, opts = {}) {
  * Cached per rootDir to avoid repeated git calls within a tick.
  */
 const _mainBranchCache = new Map();
+function _pruneTimedMap(map, { maxEntries, ttlMs, getTs, now = Date.now() }) {
+  const max = Number(maxEntries) > 0 ? Number(maxEntries) : Infinity;
+  const ttl = Number(ttlMs) > 0 ? Number(ttlMs) : Infinity;
+  for (const [key, value] of map) {
+    const entryTs = Number(getTs(value)) || 0;
+    if (entryTs <= 0 || now - entryTs > ttl) map.delete(key);
+  }
+  if (map.size <= max) return;
+  const oldest = Array.from(map.entries())
+    .sort((a, b) => (Number(getTs(a[1])) || 0) - (Number(getTs(b[1])) || 0));
+  for (const [key] of oldest.slice(0, Math.max(0, map.size - max))) map.delete(key);
+}
+
+function _setMainBranchCache(cacheKey, branch) {
+  _pruneTimedMap(_mainBranchCache, {
+    maxEntries: ENGINE_DEFAULTS.mainBranchCacheMaxEntries,
+    ttlMs: ENGINE_DEFAULTS.mainBranchCacheTtlMs,
+    getTs: entry => entry?.ts,
+  });
+  _mainBranchCache.set(cacheKey, { branch, ts: Date.now() });
+}
+
 function resolveMainBranch(rootDir, configuredBranch) {
   const cacheKey = rootDir + ':' + (configuredBranch || '');
+  // _setMainBranchCache prunes on every write, which bounds the map without
+  // an extra O(n) scan on hits. The TTL check below handles per-entry expiry.
   const cached = _mainBranchCache.get(cacheKey);
-  if (cached && (Date.now() - cached.ts) < 300000) return cached.branch; // 5min TTL
+  if (cached && (Date.now() - cached.ts) < ENGINE_DEFAULTS.mainBranchCacheTtlMs) return cached.branch;
 
   const gitOpts = { cwd: rootDir, encoding: 'utf8', stdio: 'pipe', timeout: 5000, windowsHide: true };
 
@@ -695,12 +719,12 @@ function resolveMainBranch(rootDir, configuredBranch) {
   if (configuredBranch) {
     try {
       _execSync(`git rev-parse --verify "${configuredBranch}"`, gitOpts);
-      _mainBranchCache.set(cacheKey, { branch: configuredBranch, ts: Date.now() });
+      _setMainBranchCache(cacheKey, configuredBranch);
       return configuredBranch;
     } catch { /* configured branch doesn't exist locally */ }
     try {
       _execSync(`git rev-parse --verify "origin/${configuredBranch}"`, gitOpts);
-      _mainBranchCache.set(cacheKey, { branch: configuredBranch, ts: Date.now() });
+      _setMainBranchCache(cacheKey, configuredBranch);
       return configuredBranch;
     } catch { /* not on remote either */ }
   }
@@ -710,14 +734,14 @@ function resolveMainBranch(rootDir, configuredBranch) {
     const ref = _execSync('git symbolic-ref refs/remotes/origin/HEAD', gitOpts).trim();
     const branch = ref.replace('refs/remotes/origin/', '');
     if (branch) {
-      _mainBranchCache.set(cacheKey, { branch, ts: Date.now() });
+      _setMainBranchCache(cacheKey, branch);
       return branch;
     }
   } catch { /* no remote HEAD set */ }
 
   // 3. Fallback
   const fallback = configuredBranch || 'main';
-  _mainBranchCache.set(cacheKey, { branch: fallback, ts: Date.now() });
+  _setMainBranchCache(cacheKey, fallback);
   return fallback;
 }
 
@@ -885,9 +909,15 @@ const ENGINE_DEFAULTS = {
   maxPendingContextEntryBytes: 256 * 1024, // 256 KB — cap each pendingContexts entry to prevent huge PR comments from bloating cooldowns.json
   maxDispatchPromptBytes: 1024 * 1024, // 1 MB — dispatch items with prompts larger than this sidecar to engine/contexts/ to prevent dispatch.json OOM (#1167)
   maxStateFileBytes: 100 * 1024 * 1024, // 100 MB — fail startup with a clear error when dispatch.json / cooldowns.json exceed this, rather than silently OOMing on JSON.parse (#1167)
+  mainBranchCacheTtlMs: 300000, // 5min — cache git default-branch detection, then prune expired entries
+  mainBranchCacheMaxEntries: 100, // bound repo/branch detection cache in long-lived dashboard/engine processes
+  removeWorktreeFailureTtlMs: 24 * 60 * 60 * 1000, // stale failed paths are forgotten after a day
+  removeWorktreeFailureMaxEntries: 1000, // bound failed-worktree retry suppression cache
   ccMaxTurns: 50, // max tool-use turns for CC/doc-chat before CLI stops
   ccSessionTtlMs: 7 * 24 * 60 * 60 * 1000, // 7d — keep chats resumable after breaks, still bounded by turn cap
   docSessionTtlMs: 7 * 24 * 60 * 60 * 1000, // 7d — longer-lived doc sessions, still bounded
+  docSessionMaxEntries: 200, // cap doc-chat session map/disk store by least-recent activity
+  ccLiveStreamMaxAgeMs: 30 * 60 * 1000, // hard cap reconnect buffers if abort/cleanup stalls
   maxLlmRawBytes: 256 * 1024, // keep only a bounded stdout tail from direct Claude calls
   maxLlmStderrBytes: 64 * 1024, // keep only a bounded stderr tail from direct Claude calls
   maxLlmLineBufferBytes: 128 * 1024, // cap the incremental JSON line buffer to avoid malformed-stream OOMs
@@ -2485,6 +2515,13 @@ function mutatePullRequests(filePath, mutator) {
  * 2. cmd /c rd /s /q as final fallback handles any remaining reserved names
  */
 const _removeWorktreeFailures = new Map(); // path → { count, lastAttempt }
+function _pruneRemoveWorktreeFailures() {
+  _pruneTimedMap(_removeWorktreeFailures, {
+    maxEntries: ENGINE_DEFAULTS.removeWorktreeFailureMaxEntries,
+    ttlMs: ENGINE_DEFAULTS.removeWorktreeFailureTtlMs,
+    getTs: entry => entry?.lastAttempt,
+  });
+}
 
 // Windows reserved device names that cannot be deleted via normal paths
 const _WIN_RESERVED_NAMES = new Set([
@@ -2583,6 +2620,7 @@ function removeWorktree(wtPath, gitRoot, worktreeRoot) {
     log('warn', `removeWorktree: refusing to remove ${wtPath} — not under ${worktreeRoot}`);
     return false;
   }
+  _pruneRemoveWorktreeFailures();
   // Skip paths that failed 3+ times — retry after 1 hour cooldown
   const prior = _removeWorktreeFailures.get(resolved);
   if (prior && prior.count >= 3 && Date.now() - prior.lastAttempt < 3600000) return false;
@@ -2619,6 +2657,7 @@ function removeWorktree(wtPath, gitRoot, worktreeRoot) {
       fail.count++;
       fail.lastAttempt = Date.now();
       _removeWorktreeFailures.set(resolved, fail);
+      _pruneRemoveWorktreeFailures();
       if (fail.count <= 3) log('warn', `removeWorktree: failed for ${wtPath} (attempt ${fail.count}/3): ${rmErr.message}`);
       return false;
     }

package/engine.js

@@ -154,6 +154,17 @@ const realActivityMap = new Map(); // dispatchId → timestamp of last agent std
 let engineRestartGraceUntil = 0; // timestamp — suppress orphan detection until this time
 const engineRestartGraceExempt = new Set(); // dispatch IDs with confirmed-dead PIDs at restart — bypass grace period
 
+function cleanupTempAgent(agentId) {
+  if (!tempAgents.has(agentId)) return;
+  tempAgents.delete(agentId);
+  try {
+    const agentDir = path.join(AGENTS_DIR, agentId);
+    // Keep output archive but remove temp agent directory (live-output.log etc.)
+    fs.rmSync(agentDir, { recursive: true, force: true });
+    log('info', `Temp agent ${agentId} cleaned up`);
+  } catch { /* cleanup */ }
+}
+
 // Per-tick cache of refs that failed to fetch — avoids repeating 30s ETIMEDOUT for same missing ref
 // Cleared at the start of each tick cycle (see tickInner)
 const _failedRefCache = new Set();
@@ -692,6 +703,7 @@ async function spawnAgent(dispatchItem, config) {
           log('error', `Failed to create worktree for ${branchName}: ${err.message}${err.stderr ? '\n' + err.stderr.toString().slice(0, 500) : ''}`);
           _cleanupPromptFiles();
           completeDispatch(id, DISPATCH_RESULT.ERROR, 'Worktree creation failed: ' + (err.message || '').slice(0, 200));
+          cleanupTempAgent(agentId);
           return null;
         }
       }
@@ -945,6 +957,7 @@ async function spawnAgent(dispatchItem, config) {
                 });
               } catch (e) { log('warn', `Failed to auto-queue conflict-fix: ${e.message}`); }
             }
+            cleanupTempAgent(agentId);
             return;
           }
         } catch (e) {
@@ -1091,6 +1104,7 @@ async function spawnAgent(dispatchItem, config) {
     // orphan detector's "logSize > stub-only" check can tell this apart from a
     // hung process. Then rethrow so the dispatch loop handles it normally.
     try { fs.appendFileSync(liveOutputPath, `[${new Date().toISOString()}] spawn-failed: ${spawnErr.message}\n[process-exit] spawn-failed\n`); } catch { /* cleanup-only best effort */ }
+    cleanupTempAgent(agentId);
     throw spawnErr;
   }
 
@@ -1222,6 +1236,7 @@ async function spawnAgent(dispatchItem, config) {
         try { fs.appendFileSync(liveOutputPath, `\n[steering-failed] No session to resume. Message was: ${steerMsg}\n`); } catch {}
         activeProcesses.delete(id);
         completeDispatch(id, DISPATCH_RESULT.SUCCESS, 'Steering skipped (no session)', '', { processWorkItemFailure: false });
+        cleanupTempAgent(agentId);
         return;
       }
 
@@ -1252,6 +1267,7 @@ async function spawnAgent(dispatchItem, config) {
         try { fs.appendFileSync(liveOutputPath, `\n[steering-failed] Could not write prompt. Message was: ${steerMsg}\n`); } catch {}
         activeProcesses.delete(id);
         completeDispatch(id, DISPATCH_RESULT.SUCCESS, 'Steering prompt write failed', '', { processWorkItemFailure: false });
+        cleanupTempAgent(agentId);
         return;
       }
 
@@ -1274,6 +1290,7 @@ async function spawnAgent(dispatchItem, config) {
         try { fs.unlinkSync(steerPromptPath); } catch {}
         activeProcesses.delete(id);
         completeDispatch(id, DISPATCH_RESULT.SUCCESS, 'Steering not supported by runtime', '', { processWorkItemFailure: false });
+        cleanupTempAgent(agentId);
         return;
       }
 
@@ -1302,6 +1319,7 @@ async function spawnAgent(dispatchItem, config) {
         try { fs.unlinkSync(steerPromptPath); } catch {}
         activeProcesses.delete(id);
         completeDispatch(id, DISPATCH_RESULT.SUCCESS, 'Steering spawn failed', '', { processWorkItemFailure: false });
+        cleanupTempAgent(agentId);
         return;
       }
 
@@ -1420,6 +1438,7 @@ async function spawnAgent(dispatchItem, config) {
       try { fs.unlinkSync(sysPromptPath); } catch { /* cleanup */ }
       try { fs.unlinkSync(promptPath); } catch { /* cleanup */ }
       try { fs.unlinkSync(promptPath.replace(/prompt-/, 'pid-').replace(/\.md$/, '.pid')); } catch { /* cleanup */ }
+      cleanupTempAgent(agentId);
       return;
     }
 
@@ -1443,6 +1462,7 @@ async function spawnAgent(dispatchItem, config) {
       try { fs.unlinkSync(sysPromptPath); } catch { /* cleanup */ }
       try { fs.unlinkSync(promptPath); } catch { /* cleanup */ }
       try { fs.unlinkSync(promptPath.replace(/prompt-/, 'pid-').replace(/\.md$/, '.pid')); } catch { /* cleanup */ }
+      cleanupTempAgent(agentId);
       return;
     }
 
@@ -1539,16 +1559,7 @@ async function spawnAgent(dispatchItem, config) {
       } catch (err) { log('warn', `Artifact tracking: ${err.message}`); }
     }
 
-    // Clean up temp agent directory
-    if (tempAgents.has(agentId)) {
-      tempAgents.delete(agentId);
-      try {
-        const agentDir = path.join(AGENTS_DIR, agentId);
-        // Keep output archive but remove temp agent directory (live-output.log etc.)
-        fs.rmSync(agentDir, { recursive: true, force: true });
-        log('info', `Temp agent ${agentId} cleaned up`);
-      } catch { /* cleanup */ }
-    }
+    cleanupTempAgent(agentId);
   }
 
   proc.on('close', onAgentClose);
@@ -1558,6 +1569,7 @@ async function spawnAgent(dispatchItem, config) {
     activeProcesses.delete(id);
     realActivityMap.delete(id);
     completeDispatch(id, DISPATCH_RESULT.ERROR, `Spawn error: ${err.message}`);
+    cleanupTempAgent(agentId);
   });
 
   // Safety: if process exits immediately (within 3s), log it

package/package.json

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