@yemi33/minions 0.1.2028 → 0.1.2030

package/dashboard/js/refresh.js

@@ -4,14 +4,21 @@
 // Registry: add one line per page. Counter returns a value; badge shows when value increases.
 const _pageCounters = {
   home:      function(d) { return (d.dispatch?.completed || []).length; },
-  work:      function(d) { return (d.workItems || []).length + '|' + (d.workItems || []).filter(function(w) { return w.status === 'done' || w.status === 'failed'; }).length; },
+  // work signature: total + in-flight count. State transitions (pending /
+  // dispatched → done) flip the dot; per-item title/updatedAt churn doesn't (F9/S4).
+  work:      function(d) { return (d.workItems || []).length + '|' + (d.workItems || []).filter(function(w) { return w.status === 'pending' || w.status === 'dispatched'; }).length; },
   plans:     function(d) { return (d.prdProgress?.complete || 0) + '|' + (d.plans || []).length + '|' + (d.plans || []).map(function(p) { return p.status || ''; }).join(','); },
   prs:       function(d) { return (d.pullRequests || []).length + '|' + (d.pullRequests || []).filter(function(p) { return p.status === 'merged'; }).length; },
   inbox:     function(d) { return (d.inbox || []).length + '|' + (d.notes?.content || '').length; },
-  watches:   function(d) { return (d.watches || []).length + '|' + (d.watches || []).map(function(w) { return [w.id || '', w.status || '', w.triggerCount || 0, w.last_triggered || ''].join(':'); }).join(','); },
+  // watches signature: count + max(last_triggered). Dot fires when any watch
+  // triggers or the count changes; triggerCount removed because it advances
+  // on the same event as last_triggered (F9/S4).
+  watches:   function(d) { return (d.watches || []).length + '|' + (d.watches || []).reduce(function(m, w) { return Math.max(m, new Date(w.last_triggered || 0).getTime() || 0); }, 0); },
   meetings:  function(d) { return (d.meetings || []).length + '|' + (d.meetings || []).reduce(function(s, m) { return s + (m.round || 0); }, 0); },
   pipelines: function(d) { return (d.pipelines || []).length + '|' + (d.pipelines || []).reduce(function(s, p) { return s + (p.runs || []).length; }, 0); },
   schedule:  function(d) { return (d.schedules || []).length; },
+  // tools signature: skills count + mcp servers count.
+  tools:     function(d) { return (d.skills || []).length + '|' + (d.mcpServers || []).length; },
   engine:    function(d) { return (d.dispatch?.completed || []).filter(function(c) { return c.result === 'error'; }).length; },
   qa:        function(d) { return (d.qaRuns?.total || 0) + '|' + (d.qaRuns?.sig || ''); },
 };

package/dashboard/js/render-pipelines.js

@@ -6,6 +6,9 @@ let _pipelinePollInterval = null;
 const PIPELINE_PER_PAGE = 25;
 let _pipelinePage = 0;
 let _pipelineTotalPages = 1;
+// F7: pipeline ids whose enable/disable POST is in flight — used to render
+// the toggle button as `disabled` so a second click can't race the first.
+const _pipelineToggleInFlight = new Set();
 function _stopPipelinePoll() { if (_pipelinePollInterval) { clearInterval(_pipelinePollInterval); _pipelinePollInterval = null; } _pipelinePollId = null; }
 
 /**
@@ -389,7 +392,7 @@ function openPipelineDetail(id) {
           '<button class="pr-pager-btn" style="font-size:9px;padding:2px 8px;color:var(--yellow);border-color:var(--yellow)" onclick="_retriggerPipeline(\'' + escHtml(id) + '\',this)">Retrigger</button>'
         : '<button class="pr-pager-btn" style="font-size:9px;padding:2px 8px;color:var(--green);border-color:var(--green)" onclick="_triggerPipeline(\'' + escHtml(id) + '\',this)">Run Now</button>') +
       '<button class="pr-pager-btn" style="font-size:9px;padding:2px 8px;color:var(--blue);border-color:var(--blue)" onclick="openEditPipelineModal(\'' + escHtml(id) + '\')">Edit</button>' +
-      '<button class="pr-pager-btn" style="font-size:9px;padding:2px 8px" onclick="_togglePipelineEnabled(\'' + escHtml(id) + '\',' + !p.enabled + ',this)">' + (p.enabled !== false ? 'Disable' : 'Enable') + '</button>' +
+      '<button class="pr-pager-btn' + (_pipelineToggleInFlight.has(id) ? ' disabled' : '') + '" style="font-size:9px;padding:2px 8px" onclick="_togglePipelineEnabled(\'' + escHtml(id) + '\',' + !p.enabled + ',this)">' + (p.enabled !== false ? 'Disable' : 'Enable') + '</button>' +
       '<button class="pr-pager-btn" style="font-size:9px;padding:2px 8px;color:var(--red);border-color:var(--red)" onclick="_deletePipelineConfirm(\'' + escHtml(id) + '\')">Delete</button>' +
     '</div>' +
   '</div>';
@@ -566,14 +569,46 @@ async function _retriggerPipeline(id, btn) {
 }
 
 async function _togglePipelineEnabled(id, enabled, btn) {
+  if (_pipelineToggleInFlight.has(id)) return; // F7: prevent double-fires
+  // F7: optimistic — flip cached `enabled` and re-render both the pipeline
+  // card list (so the DISABLED badge appears/clears) and the detail modal
+  // (so the toggle button label switches) immediately. Rollback on failure.
+  var p = _pipelinesData.find(function(x) { return x.id === id; });
+  var prevEnabled = p ? p.enabled : undefined;
+  if (p) p.enabled = enabled;
+  _pipelineToggleInFlight.add(id);
   if (btn) { btn.textContent = enabled ? 'Enabling...' : 'Disabling...'; btn.style.pointerEvents = 'none'; }
+  renderPipelines(_pipelinesData);
+  if (document.getElementById('modal')?.classList?.contains('open') && _pipelinePollId === id) {
+    openPipelineDetail(id);
+  }
   showToast('cmd-toast', enabled ? 'Pipeline enabled' : 'Pipeline disabled', true);
   try {
     var res = await fetch('/api/pipelines/update', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ id: id, enabled: enabled }) });
-    if (res.ok) { refresh(); await _refreshPipelineDetail(id); }
-    else { showToast('cmd-toast', 'Failed to ' + (enabled ? 'enable' : 'disable') + ' pipeline', false); }
-  } catch (e) { showToast('cmd-toast', 'Error: ' + e.message, false); }
-  if (btn) { btn.textContent = enabled ? 'Disable' : 'Enable'; btn.style.pointerEvents = ''; }
+    if (res.ok) {
+      _pipelineToggleInFlight.delete(id);
+      renderPipelines(_pipelinesData);
+      refresh();
+      await _refreshPipelineDetail(id);
+    } else {
+      if (p) p.enabled = prevEnabled;
+      _pipelineToggleInFlight.delete(id);
+      renderPipelines(_pipelinesData);
+      if (document.getElementById('modal')?.classList?.contains('open') && _pipelinePollId === id) {
+        openPipelineDetail(id);
+      }
+      showToast('cmd-toast', 'Failed to ' + (enabled ? 'enable' : 'disable') + ' pipeline', false);
+    }
+  } catch (e) {
+    if (p) p.enabled = prevEnabled;
+    _pipelineToggleInFlight.delete(id);
+    renderPipelines(_pipelinesData);
+    if (document.getElementById('modal')?.classList?.contains('open') && _pipelinePollId === id) {
+      openPipelineDetail(id);
+    }
+    showToast('cmd-toast', 'Error: ' + e.message, false);
+  }
+  if (btn) { btn.style.pointerEvents = ''; }
 }
 
 async function _continuePipeline(id, stageId, btn) {

package/dashboard/js/render-schedules.js

@@ -5,6 +5,10 @@
 const _DAYS = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
 const _DAY_NAMES = ['Sundays', 'Mondays', 'Tuesdays', 'Wednesdays', 'Thursdays', 'Fridays', 'Saturdays'];
 
+// F7: schedule ids whose enable/disable POST is in flight — used to render
+// the toggle button as `disabled` so a second click can't race the first.
+const _schedToggleInFlight = new Set();
+
 function _formatCronDowList(days, timeStr, fallback) {
   const normalized = [...new Set(days)].sort((a, b) => a - b);
   const key = normalized.join(',');
@@ -346,7 +350,7 @@ function renderSchedules(schedules) {
         '<td><span class="pr-date">' + escHtml(lastRun) + '</span></td>' +
         '<td style="white-space:nowrap">' +
           '<button class="pr-pager-btn" style="font-size:9px;padding:1px 6px;color:var(--green);border-color:var(--green);margin-right:4px" onclick="event.stopPropagation();runScheduleNow(\'' + escHtml(s.id) + '\',this)" title="Run now">Run now</button>' +
-          '<button class="pr-pager-btn" style="font-size:9px;padding:1px 6px;color:' + (s.enabled ? 'var(--yellow)' : 'var(--green)') + ';border-color:' + (s.enabled ? 'var(--yellow)' : 'var(--green)') + ';margin-right:4px" onclick="event.stopPropagation();toggleScheduleEnabled(\'' + escHtml(s.id) + '\',' + !s.enabled + ')" title="' + (s.enabled ? 'Disable' : 'Enable') + '">' + (s.enabled ? '&#x23F8;' : '&#x25B6;') + '</button>' +
+          '<button class="pr-pager-btn' + (_schedToggleInFlight.has(s.id) ? ' disabled' : '') + '" style="font-size:9px;padding:1px 6px;color:' + (s.enabled ? 'var(--yellow)' : 'var(--green)') + ';border-color:' + (s.enabled ? 'var(--yellow)' : 'var(--green)') + ';margin-right:4px" onclick="event.stopPropagation();toggleScheduleEnabled(\'' + escHtml(s.id) + '\',' + !s.enabled + ')" title="' + (s.enabled ? 'Disable' : 'Enable') + '">' + (s.enabled ? '&#x23F8;' : '&#x25B6;') + '</button>' +
           '<button class="pr-pager-btn" style="font-size:9px;padding:1px 6px;color:var(--blue);border-color:var(--blue);margin-right:4px" onclick="event.stopPropagation();openEditScheduleModal(\'' + escHtml(s.id) + '\')" title="Edit">&#x270E;</button>' +
           '<button class="pr-pager-btn" style="font-size:9px;padding:1px 6px;color:var(--red);border-color:var(--red)" onclick="event.stopPropagation();deleteSchedule(\'' + escHtml(s.id) + '\')" title="Delete">&#x2715;</button>' +
         '</td>' +
@@ -574,19 +578,37 @@ function _findSchedRow(id) {
 }
 
 async function toggleScheduleEnabled(id, enabled) {
-  // Optimistic toggle — swap badge text immediately
-  var row = _findSchedRow(id);
-  if (row) { var badge = row.querySelector('.status-badge'); if (badge) badge.textContent = enabled ? 'ENABLED' : 'DISABLED'; }
+  if (_schedToggleInFlight.has(id)) return; // F7: prevent double-fires
+  // F7: optimistic — flip cached `enabled` on the schedule + re-render so the
+  // badge AND the toggle button switch synchronously. Rollback on failure.
+  const list = window._lastSchedules || [];
+  const s = list.find(x => x.id === id);
+  const prevEnabled = s ? s.enabled : undefined;
+  if (s) s.enabled = enabled;
+  _schedToggleInFlight.add(id);
+  renderSchedules(list);
   try {
     const res = await fetch('/api/schedules/update', {
       method: 'POST', headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({ id, enabled })
     });
-    if (res.ok) { refresh(); } else {
+    if (res.ok) {
+      _schedToggleInFlight.delete(id);
+      renderSchedules(list);
+      refresh();
+    } else {
       const d = await res.json().catch(() => ({}));
-      _showScheduleError('Toggle failed: ' + (d.error || 'unknown')); refresh();
+      if (s) s.enabled = prevEnabled;
+      _schedToggleInFlight.delete(id);
+      renderSchedules(list);
+      showToast('cmd-toast', 'Toggle failed: ' + (d.error || 'unknown'), false);
     }
-  } catch (e) { _showScheduleError('Toggle error: ' + e.message); refresh(); }
+  } catch (e) {
+    if (s) s.enabled = prevEnabled;
+    _schedToggleInFlight.delete(id);
+    renderSchedules(list);
+    showToast('cmd-toast', 'Toggle error: ' + e.message, false);
+  }
 }
 
 async function runScheduleNow(id, btn) {

package/dashboard/js/render-watches.js

@@ -9,6 +9,10 @@ const _WATCH_STATUS_BADGES = {
   expired: '<span class="pr-badge" style="background:rgba(139,148,158,0.15);color:var(--muted);border-color:var(--muted)">expired</span>',
 };
 
+// F7: ids whose pause/resume POST is in flight — used to render the toggle
+// button as `disabled` so a second click can't race the first request.
+const _watchToggleInFlight = new Set();
+
 // Cache of target types fetched from /api/watches/target-types. Populated on
 // first modal open and refreshed per modal show. Each entry:
 //   { value, label, conditions: [...], description }
@@ -158,11 +162,12 @@ function renderWatches(watchesData) {
       '<td><span class="pr-date">' + escHtml(lastChecked) + '</span></td>' +
       '<td style="white-space:nowrap">';
 
-    // Pause/Resume button
+    // Pause/Resume button (F7: marks as `disabled` while POST in flight)
+    var pauseBusyCls = _watchToggleInFlight.has(w.id) ? ' disabled' : '';
     if (w.status === 'active') {
-      html += '<button class="pr-pager-btn" style="font-size:9px;padding:1px 6px;color:var(--yellow);border-color:var(--yellow);margin-right:4px" onclick="event.stopPropagation();toggleWatchPause(\'' + escHtml(w.id) + '\',true)" title="Pause">&#x23F8;</button>';
+      html += '<button class="pr-pager-btn' + pauseBusyCls + '" style="font-size:9px;padding:1px 6px;color:var(--yellow);border-color:var(--yellow);margin-right:4px" onclick="event.stopPropagation();toggleWatchPause(\'' + escHtml(w.id) + '\',true)" title="Pause">&#x23F8;</button>';
     } else if (w.status === 'paused') {
-      html += '<button class="pr-pager-btn" style="font-size:9px;padding:1px 6px;color:var(--green);border-color:var(--green);margin-right:4px" onclick="event.stopPropagation();toggleWatchPause(\'' + escHtml(w.id) + '\',false)" title="Resume">&#x25B6;</button>';
+      html += '<button class="pr-pager-btn' + pauseBusyCls + '" style="font-size:9px;padding:1px 6px;color:var(--green);border-color:var(--green);margin-right:4px" onclick="event.stopPropagation();toggleWatchPause(\'' + escHtml(w.id) + '\',false)" title="Resume">&#x25B6;</button>';
     }
 
     // Delete button
@@ -343,7 +348,16 @@ function openWatchDetail(id) {
 // ─── CRUD Actions ───────────────────────────────────────────────────────────
 
 function toggleWatchPause(id, pause) {
+  if (_watchToggleInFlight.has(id)) return; // F7: prevent double-fires
   var newStatus = pause ? 'paused' : 'active';
+  var list = window._lastWatches || [];
+  var w = list.find(function(x) { return x.id === id; });
+  var prevStatus = w ? w.status : null;
+  // F7: optimistic — flip cached status + re-render so the badge AND the
+  // pause/resume action button switch synchronously. Rollback on failure.
+  if (w) { w.status = newStatus; }
+  _watchToggleInFlight.add(id);
+  renderWatches(list);
   showToast('cmd-toast', (pause ? 'Pausing' : 'Resuming') + ' watch...', true);
   fetch('/api/watches/update', {
     method: 'POST',
@@ -351,9 +365,20 @@ function toggleWatchPause(id, pause) {
     body: JSON.stringify({ id: id, status: newStatus })
   }).then(async function(res) {
     var data = await res.json().catch(function() { return {}; });
-    if (!res.ok || data.error) showToast('cmd-toast', 'Error: ' + (data.error || ('HTTP ' + res.status)), false);
-    else if (typeof refresh === 'function') refresh();
+    if (!res.ok || data.error) {
+      if (w) { w.status = prevStatus; }
+      _watchToggleInFlight.delete(id);
+      renderWatches(list);
+      showToast('cmd-toast', 'Error: ' + (data.error || ('HTTP ' + res.status)), false);
+      return;
+    }
+    _watchToggleInFlight.delete(id);
+    renderWatches(list);
+    if (typeof refresh === 'function') refresh();
   }).catch(function(err) {
+    if (w) { w.status = prevStatus; }
+    _watchToggleInFlight.delete(id);
+    renderWatches(list);
     showToast('cmd-toast', 'Error: ' + err.message, false);
   });
 }

package/dashboard.js

@@ -25,6 +25,8 @@ const ado = require('./engine/ado');
 const gh = require('./engine/github');
 const issues = require('./engine/issues');
 const watchesMod = require('./engine/watches');
+const meetingMod = require('./engine/meeting');
+const qaRunsMod = require('./engine/qa-runs');
 const routing = require('./engine/routing');
 const playbook = require('./engine/playbook');
 const dispatchMod = require('./engine/dispatch');
@@ -1593,10 +1595,27 @@ const _slowMtimeTrackedFiles = () => queries.getStatusSlowStateMtimePaths(CONFIG
 let _lastMtimes = {}; // { filePath: mtimeMs } — fast-state baseline
 let _lastSlowMtimes = {}; // { filePath: mtimeMs } — slow-state baseline
 
+// Stat a tracked path with transient-error tolerance. ENOENT (file/dir doesn't
+// exist) is normal — fresh installs, deleted projects, empty PRD dirs all hit
+// this — and maps to 0 so the entry just doesn't bust the cache. EBUSY /
+// EACCES / EPERM are transient on Windows (OneDrive sync, antivirus scan,
+// file replication service); falling through to 0 would produce oscillating
+// mtimes (real, then 0, then real again) that look like a real change on
+// every other poll. Preserving the previous successful mtime on those errors
+// keeps the cache stable across short lock windows.
+function _statMtimeMs(fp, prevSnapshot) {
+  try {
+    return fs.statSync(fp).mtimeMs;
+  } catch (e) {
+    if (e && e.code === 'ENOENT') return 0;
+    return prevSnapshot && (fp in prevSnapshot) ? prevSnapshot[fp] : 0;
+  }
+}
+
 function _getMtimes() {
   const result = {};
   for (const fp of _mtimeTrackedFiles()) {
-    try { result[fp] = fs.statSync(fp).mtimeMs; } catch { result[fp] = 0; }
+    result[fp] = _statMtimeMs(fp, _lastMtimes);
   }
   return result;
 }
@@ -1604,7 +1623,7 @@ function _getMtimes() {
 function _getSlowMtimes() {
   const result = {};
   for (const fp of _slowMtimeTrackedFiles()) {
-    try { result[fp] = fs.statSync(fp).mtimeMs; } catch { result[fp] = 0; }
+    result[fp] = _statMtimeMs(fp, _lastSlowMtimes);
   }
   return result;
 }
@@ -1677,25 +1696,41 @@ function _buildStatusFastState() {
     metrics: getMetrics(),
     workItems: getWorkItems(),
     watches: watchesMod.getWatches(),
-    meetings: (() => { try { return require('./engine/meeting').getMeetings(); } catch { return []; } })(),
+    meetings: _safeStatusSlice('meetings', () => meetingMod.getMeetings(), []),
     // QA runs — surfaced for the sidebar activity-dot counter and any future
     // CC/aggregate view. Tab-level rendering keeps its own /api/qa/runs poll
     // (5 s while the QA page is mounted). qa-runs.json is in the mtime tracker
     // so a new run lights the dot within one /api/status poll cycle (~4 s).
-    qaRuns: (() => {
-      try {
-        const runs = require('./engine/qa-runs').listRuns({ limit: 50 }) || [];
-        return {
-          total: runs.length,
-          // Signature of (id, status) for the most recent 20 runs so the
-          // sidebar counter advances on status flips AND on new entries.
-          sig: runs.slice(0, 20).map(r => (r && r.id || '') + ':' + (r && r.status || '')).join(','),
-        };
-      } catch { return { total: 0, sig: '' }; }
-    })(),
+    // Uses the unsorted summary helper rather than listRuns({limit:50}) — the
+    // latter reads + sorts the FULL qa-runs.json on every fast-state rebuild
+    // and would charge O(N log N) to the /api/status hot path. The summary
+    // helper returns { total, sig } without sorting; that's all the sidebar
+    // counter needs to detect new runs and status flips.
+    qaRuns: _safeStatusSlice('qaRuns', () => qaRunsMod.summarizeRunsForStatus(), { total: 0, sig: '' }),
   };
 }
 
+// Run a status-slice producer with rate-limited error logging. The lazy-
+// require IIFEs this replaces silently degraded to fallback values if the
+// underlying module had a syntax error or got renamed — sidebar dots went
+// dark with no diagnostic. We keep returning the fallback so the rest of
+// the status payload survives, but we log once per minute per slice so a
+// persistent error doesn't spam the engine log AND isn't invisible.
+const _statusSliceErrorLastLogged = new Map();
+function _safeStatusSlice(name, fn, fallback) {
+  try {
+    return fn();
+  } catch (e) {
+    const now = Date.now();
+    const last = _statusSliceErrorLastLogged.get(name) || 0;
+    if (now - last > 60000) {
+      _statusSliceErrorLastLogged.set(name, now);
+      console.error('[status] slice ' + name + ' failed: ' + (e && e.message || e));
+    }
+    return fallback;
+  }
+}
+
 // Build the slow-state slice (rarely-changing data: ~60s TTL).
 function _buildStatusSlowState() {
   const prdInfo = getPrdInfo();

package/engine/dispatch.js

@@ -7,7 +7,7 @@ const fs = require('fs');
 const path = require('path');
 const shared = require('./shared');
 const queries = require('./queries');
-const { setCooldownFailure } = require('./cooldown');
+const { setCooldown, setCooldownFailure } = require('./cooldown');
 
 const { safeJson, mutateJsonFileLocked, mutateWorkItems,
   mutatePullRequests, getProjects, projectWorkItemsPath, projectPrPath, log, ts, dateStamp,
@@ -170,7 +170,27 @@ function addToDispatch(item) {
     added = true;
     return dispatch;
   });
-  if (added) log('info', `Queued dispatch: ${item.id} (${item.type} → ${item.agent})`);
+  if (added) {
+    log('info', `Queued dispatch: ${item.id} (${item.type} → ${item.agent})`);
+    // W-mph8xt88000ke0fc — Stamp the dispatch cooldown ONLY when the item
+    // actually survives the queue-time dedup gauntlet. Discover-side blocks
+    // (discoverFromPrs build-failure / review-feedback / merge-conflict,
+    // discoverFromWorkItems, discoverCentralWorkItems) used to call
+    // setCooldown(key) inline the instant a candidate item was built,
+    // BEFORE addToDispatch ran the prDedupeKey / workItem-id / dispatchKey
+    // dedup checks. The losing candidate left an orphan cooldown that
+    // blocked re-dispatch of that cause for `cooldownMinutes || 30` minutes
+    // even though no agent ever ran (live repro:
+    // ado:office/iss/constellation#5227109 on 2026-05-22 — build-fix and
+    // human-fix landed within 38 ms; only the human-fix ran but the orphan
+    // build-fix cooldown blocked the next 24 min of retries).
+    //
+    // Callers opt in by setting `item.meta.cooldownKey`. When absent (e.g.
+    // lifecycle.js auto-redispatches that intentionally bypass the cooldown
+    // ladder), no stamp fires — same as the pre-fix behavior for those
+    // paths.
+    if (item.meta?.cooldownKey) setCooldown(item.meta.cooldownKey);
+  }
   return item.id;
 }
 

package/engine/lifecycle.js

@@ -2128,6 +2128,75 @@ function updatePrAfterFix(pr, project, source, options = {}, legacyDispatchId =
   return result;
 }
 
+// W-mph6br6a0006a2b9 (F9): record an agent-error fix completion onto the PR
+// so the engine.js same-head guard relaxes for the next tick. A fix dispatch
+// that crashed (non-zero exit, hard contract failure, nonce mismatch) never
+// reached updatePrAfterFix and therefore left _lastDispatchByCause[cause]
+// either absent (no entry) or — worse — frozen at a prior noop record. The
+// guard at engine.js:~4254/4445 reads `outcome === 'noop' && !indeterminate`
+// to suppress re-dispatch on the same head; once a noop record exists it
+// stays in place permanently because the SHA can't advance until the fix
+// runs. Reuses the W-mpg6wptq0011cc68 sibling-flag escape-hatch: setting
+// `indeterminate: true` is sufficient to release the guard. Preserves any
+// prior `outcome` value verbatim (success/noop/etc) so downstream debugging
+// can still see what the last known classification was.
+function updatePrAfterFixError(pr, project, source, options = {}) {
+  if (!pr?.id) return null;
+  if (!options || typeof options !== 'object' || Array.isArray(options)) return null;
+  const prPath = project ? shared.projectPrPath(project) : centralPrPath();
+  const dispatchItem = options.dispatchItem || null;
+  const errorMessage = String(options.errorMessage || '').slice(0, 200);
+  const errorClass = String(options.errorClass || 'agent-error');
+  const cause = shared.getPrFixAutomationCause({
+    dispatchKey: dispatchItem?.meta?.dispatchKey,
+    source,
+    task: dispatchItem?.task,
+  });
+  let result = null;
+  shared.mutateJsonFileLocked(prPath, (prs) => {
+    if (!Array.isArray(prs)) return prs;
+    const target = shared.findPrRecord(prs, pr, project);
+    if (!target) return prs;
+    target._lastDispatchByCause = target._lastDispatchByCause
+      && typeof target._lastDispatchByCause === 'object' ? target._lastDispatchByCause : {};
+    const prior = target._lastDispatchByCause[cause] || null;
+    const now = ts();
+    const baselineHead = getPrFixBaselineHead(target);
+    // Preserve the prior `outcome` verbatim (could be 'noop' from a previous
+    // indeterminate noop, or undefined if no prior record). The same-head
+    // guard only suppresses on `outcome === 'noop' && !indeterminate`; setting
+    // `indeterminate: true` releases it regardless of outcome value.
+    const next = {
+      ...(prior || {}),
+      indeterminate: true,
+      errorClass,
+      error: errorMessage,
+      errorAt: now,
+      dispatchedAt: now,
+      dispatchId: dispatchItem?.id || prior?.dispatchId || null,
+    };
+    // Refresh headSha when we know the baseline; never clobber a prior value
+    // with empty string (loses guard fidelity for operator-readable history).
+    if (baselineHead) next.headSha = baselineHead;
+    else if (prior?.headSha) next.headSha = prior.headSha;
+    // Preserve the human-feedback comment id from the prior record OR refresh
+    // from the live PR record. Symmetric with recordPrNoOpFixAttempt so the
+    // engine.js human-feedback guard's commentId match still works once
+    // indeterminate flips back off (which it doesn't here, but state shape
+    // stays consistent across paths).
+    if (cause === shared.PR_FIX_CAUSE.HUMAN_FEEDBACK) {
+      const commentId = prior?.lastProcessedCommentId
+        || String(target.humanFeedback?.lastProcessedCommentId || '');
+      if (commentId) next.lastProcessedCommentId = commentId;
+    }
+    target._lastDispatchByCause[cause] = next;
+    result = { cause, indeterminate: true, errorClass };
+    log('warn', `Updated ${pr.id} → recorded ${cause} agent-error fix attempt (indeterminate=true) — same-head guard relaxed for next tick${errorMessage ? ` (${errorMessage.slice(0, 80)})` : ''}`);
+    return prs;
+  }, { defaultValue: [] });
+  return result;
+}
+
 // ─── Post-Merge Rebase ──────────────────────────────────────────────────────
 
 /**
@@ -4365,6 +4434,40 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
         }
       } catch (err) { log('warn', `PRD sync after fix: ${err.message}`); }
     }
+  } else if (type === WORK_TYPE.FIX && meta?.pr?.id) {
+    // W-mph6br6a0006a2b9 (F9): the fix dispatch did not complete cleanly
+    // (agent crash, non-zero exit, hard contract failure, or nonce mismatch),
+    // so updatePrAfterFix above was skipped. Without a write here the PR's
+    // `_lastDispatchByCause[cause]` either stays empty OR — if a prior
+    // indeterminate noop existed — keeps a stale record around. Stamp an
+    // agent-error indeterminate record so:
+    //   1. The same-head guard at engine.js:~4254/4445 relaxes for the next
+    //      tick (`indeterminate: true` is the W-mpg6wptq0011cc68 escape).
+    //   2. Operators reading dashboard PR detail can distinguish "agent
+    //      crashed" (errorClass='agent-error', errorAt set) from the
+    //      "indeterminate noop" case (no errorClass, branchChange === null).
+    //   3. Prior `outcome` is preserved verbatim — no state-shape churn.
+    try {
+      const failureClass = nonceMismatch?.failureClass
+        || completionContractFailure?.failureClass
+        || (structuredCompletion && typeof structuredCompletion.failure_class === 'string'
+          ? structuredCompletion.failure_class
+          : '');
+      const summary = (structuredCompletion && typeof structuredCompletion.summary === 'string'
+        ? structuredCompletion.summary
+        : '') || resultSummary || '';
+      const errorMessage = [
+        failureClass ? `failure_class=${failureClass}` : '',
+        summary || `agent exited with code ${code}`,
+      ].filter(Boolean).join(' — ');
+      updatePrAfterFixError(meta.pr, meta?.project, meta?.source, {
+        dispatchItem,
+        errorMessage,
+        errorClass: 'agent-error',
+      });
+    } catch (err) {
+      log('warn', `PR agent-error fix record for ${meta?.pr?.id || 'unknown PR'}: ${err.message}`);
+    }
   }
   checkForLearnings(agentId, config.agents[agentId], dispatchItem.task);
   if (finalResult === DISPATCH_RESULT.SUCCESS) {
@@ -4558,6 +4661,7 @@ module.exports = {
   syncPrsFromOutput,
   updatePrAfterReview,
   updatePrAfterFix,
+  updatePrAfterFixError,
   fixCompletionChangedBranch,
   handlePostMerge,
   checkForLearnings,

package/engine/qa-runs.js

@@ -28,6 +28,16 @@ const path = require('path');
 const shared = require('./shared');
 const { mutateJsonFileLocked, uid, ts, log } = shared;
 
+// Cap qa-runs.json so the file doesn't grow unboundedly over months of nightly
+// QA dispatch. Without a cap, listRuns + summarizeRunsForStatus pay O(N) on
+// every read, and /api/status's fast-state slice runs the summary on every
+// rebuild — at 10k+ historical runs the JSON parse alone starts eating into
+// the W-mpehsyhv event-loop budget that CC SSE isolation depends on. Mirrors
+// the 2500-entry cap on engine/log.json. createRun trims oldest-by-createdAt
+// when crossing the threshold; terminal-status runs that have already shipped
+// completion notifications are safe to drop.
+const QA_RUNS_MAX_RECORDS = 2000;
+
 const QA_RUN_STATUS = Object.freeze({
   PENDING: 'pending',
   RUNNING: 'running',
@@ -141,6 +151,12 @@ function createRun({ runbookId, targetName, project, workItemId } = {}) {
   mutateJsonFileLocked(qaRunsPath(), (runs) => {
     if (!Array.isArray(runs)) runs = [];
     runs.push(run);
+    // Rotation: drop oldest-by-createdAt when over the cap. Cheap because
+    // this runs only on createRun, not on every read.
+    if (runs.length > QA_RUNS_MAX_RECORDS) {
+      runs.sort((a, b) => ((a && a.createdAt) || '').localeCompare((b && b.createdAt) || ''));
+      runs = runs.slice(runs.length - QA_RUNS_MAX_RECORDS);
+    }
     return runs;
   }, { defaultValue: [] });
 
@@ -299,6 +315,30 @@ function setRunWorkItemId(id, workItemId) {
   return captured;
 }
 
+/**
+ * Cheap summary helper for the dashboard /api/status fast-state slice. Returns
+ * `{ total, sig }` without sorting the run list — the sidebar activity-dot
+ * counter only needs to detect (a) when total advances (new run created) and
+ * (b) when any status flips. `sig` joins id:status across all current runs;
+ * any change to either advances the string, which is enough signal for the
+ * counter. We deliberately skip the sort that listRuns() does because this
+ * runs on every fast-state rebuild (~every 10 s + every mtime-tracked write),
+ * and an O(N log N) sort on a 2 k-entry file would eat into the event-loop
+ * budget that CC SSE isolation (W-mpehsyhv) depends on.
+ *
+ * @returns {{ total: number, sig: string }}
+ */
+function summarizeRunsForStatus() {
+  const runs = shared.safeJsonArr(qaRunsPath());
+  if (!Array.isArray(runs) || runs.length === 0) return { total: 0, sig: '' };
+  let sig = '';
+  for (const r of runs) {
+    if (!r) continue;
+    sig += (r.id || '') + ':' + (r.status || '') + ',';
+  }
+  return { total: runs.length, sig };
+}
+
 module.exports = {
   QA_RUN_STATUS,
   TERMINAL_STATUSES,
@@ -313,7 +353,9 @@ module.exports = {
   getRun,
   listRuns,
   getRunsForWorkItem,
+  summarizeRunsForStatus,
   // Exposed for tests:
   validateTransition,
   isValidStatus,
+  QA_RUNS_MAX_RECORDS,
 };

package/engine/queries.js

@@ -1885,10 +1885,14 @@ function resetProjectGitStatusCache() {
  *     rebases.json`, `agents/<id>/managed-spawn.json` — not in the
  *     `/api/status` payload.
  *   - `pinned.md`, `schedules`, `pipeline-runs.json`, `schedule-runs.json`,
- *     PRD JSON — slow-state only.
- *   - `meetings/` directory — dir mtime semantics are flaky on Windows
- *     for file-content changes inside the dir; meeting transitions also
- *     mutate work items, which already invalidate fast state.
+ *     PRD JSON — slow-state only (see `getStatusSlowStateMtimePaths`).
+ *
+ * Files tracked PER-FILE rather than via dir mtime:
+ *   - `meetings/<id>.json` — round transitions edit each file in-place via
+ *     `engine/meeting.js#mutateMeeting`. The parent dir's mtime does not
+ *     advance on Windows NTFS for in-place edits inside an existing file,
+ *     so tracking each meeting JSON individually catches round/status flips
+ *     that dir mtime would miss. Bounded by active meeting count.
  *
  * Performance: `_getMtimes()` in dashboard.js does `fs.statSync` per path
  * per `getStatus()` call. Roughly N=4 engine paths + 2 per project today,
@@ -1928,17 +1932,13 @@ function getStatusFastStateMtimePaths(config) {
   // meetings/<id>.json (surfaced by meeting.getMeetings) — round transitions
   // edit each file in-place via mutateMeeting, so the parent dir's mtime
   // does NOT advance on Windows. Tracking each file individually catches
-  // in-file edits. Bounded by meeting count (typically <50 active); a 50-
-  // meeting fleet adds ~50 statSync calls per cache miss — still cheap.
-  // Filter `.backup` sidecars (from safe-write tempfile pattern) and
-  // non-*.json entries so corrupted state can't pollute the registry.
+  // in-file edits. Bounded by active meeting count; safeWrite's `.json.backup`
+  // tempfile sidecars are excluded by the `.json` suffix check (a path
+  // ending in `.json.backup` does not end in `.json`).
   try {
     const meetingsDir = path.join(MINIONS_DIR, 'meetings');
-    const entries = fs.readdirSync(meetingsDir);
-    for (const f of entries) {
-      if (f.endsWith('.json') && !f.endsWith('.backup.json')) {
-        files.push(path.join(meetingsDir, f));
-      }
+    for (const f of fs.readdirSync(meetingsDir)) {
+      if (f.endsWith('.json')) files.push(path.join(meetingsDir, f));
     }
   } catch { /* meetings dir absent → no meetings to track */ }
   // Per-project work-items (surfaced by getWorkItems) and pull-requests
@@ -1989,24 +1989,25 @@ function getStatusFastStateMtimePaths(config) {
  *   - `mcpServers`, version, autoMode, installId — change only on human/
  *     CLI edits, which already pop the slow-state via reloadConfig + the
  *     60 s TTL.
- *   - `~/.claude/skills/`, `~/.copilot/skills/` — user-home dirs that
- *     `extractSkillsFromOutput` writes to from the agent-close path,
- *     which already calls `invalidateStatusCache()` directly.
+ *   - `~/.claude/skills/`, `~/.copilot/skills/`, `<project>/.claude/skills/`,
+ *     `<project>/.github/skills/` — `extractSkillsFromOutput` writes here
+ *     from the agent-close path, which already calls
+ *     `invalidateStatusCache({includeSlow: true})` directly. Tracking the
+ *     user-home dir is additionally harmful because it's shared with every
+ *     Claude Code session on the machine; non-Minions activity would
+ *     otherwise bust this fleet's dashboard cache.
  *   - project git state — already invalidated via the
  *     `_setOnProjectGitStatusChanged` callback into `invalidateStatusCache`
  *     (W-mpgrk5cy fix); also tracked in fast-state via `.git/logs/HEAD`.
  */
-function getStatusSlowStateMtimePaths(config) {
-  const projects = getProjects(config || getConfig());
-  const files = [
+function getStatusSlowStateMtimePaths(_config) {
+  // _config accepted for symmetry with getStatusFastStateMtimePaths but
+  // unused — every entry below is a fleet-global path.
+  return [
     // prd/*.json (surfaced by getPrdInfo) — engine writes via syncPrdFromPrs,
-    // the materializer, and plan-to-prd outputs. Dir mtime advances on entry
-    // add/remove; in-file edits use getPrdInfo's own per-file mtime cache so
-    // small-content flips still surface via the 10 s TTL backstop, but the
-    // big "new PRD created" event surfaces immediately.
+    // the materializer, and plan-to-prd outputs.
     PRD_DIR,
-    // prd/archive/*.json — manual archive moves PRDs here; dir mtime catches
-    // the move.
+    // prd/archive/*.json — manual archive moves PRDs here.
     path.join(PRD_DIR, 'archive'),
     // prd/guides/*.md — verify agent writes new files here on E2E completion.
     path.join(MINIONS_DIR, 'prd', 'guides'),
@@ -2016,26 +2017,12 @@ function getStatusSlowStateMtimePaths(config) {
     // stage transition (the most user-visible slow-state lag pre-fix).
     path.join(ENGINE_DIR, 'pipeline-runs.json'),
     // pipelines/*.json — pipeline definitions, edited by humans + plan agents.
-    // Dir mtime is fine because pipeline edits are wholesale file replacements
-    // (no in-place tweaks once a pipeline is authored).
     path.join(MINIONS_DIR, 'pipelines'),
     // pinned.md — single file, dashboard-side writes already call
     // invalidateStatusCache({includeSlow:true}); tracker entry catches any
     // CLI/editor edit that bypasses the API.
     path.join(MINIONS_DIR, 'pinned.md'),
-    // engine/skill-states/ — engine writes when agents extract new skills.
-    // Dir mtime catches new skill files. Skips per-skill in-place edits which
-    // the agent-close invalidate already covers.
-    SKILLS_DIR,
   ];
-  // Per-project local skill dirs — agents extract project-scoped skills here.
-  for (const p of projects) {
-    if (p && p.localPath) {
-      files.push(path.join(p.localPath, '.claude', 'skills'));
-      files.push(path.join(p.localPath, '.github', 'skills'));
-    }
-  }
-  return files;
 }
 
 // ── Exports ─────────────────────────────────────────────────────────────────

package/engine.js

@@ -4315,7 +4315,7 @@ async function discoverFromPrs(config, project) {
       const item = buildPrDispatch(agentId, config, project, pr, 'review', {
         pr_id: pr.id, pr_number: prNumber, pr_title: pr.title || '', pr_branch: prBranch,
         pr_author: pr.agent || '', pr_url: pr.url || '',
-      }, `Review ${pr.id}: ${pr.title}`, { dispatchKey: key, source: 'pr', pr, branch: prBranch, project: projMeta });
+      }, `Review ${pr.id}: ${pr.title}`, { dispatchKey: key, cooldownKey: key, source: 'pr', pr, branch: prBranch, project: projMeta });
       if (item) { newWork.push(item); fixDispatched = true; }
     }
 
@@ -4424,7 +4424,7 @@ async function discoverFromPrs(config, project) {
         pr_id: pr.id, pr_number: prNumber, pr_title: pr.title || '', pr_branch: prBranch,
         reviewer: 'Human Reviewer',
         review_note: reviewNote,
-      }, `Fix ${pr.id}: ${pr.title || ''} — human feedback`, { dispatchKey: key, automationCauseKey: humanCauseKey, source: 'pr-human-feedback', pr, branch: prBranch, project: projMeta });
+      }, `Fix ${pr.id}: ${pr.title || ''} — human feedback`, { dispatchKey: key, cooldownKey: key, automationCauseKey: humanCauseKey, source: 'pr-human-feedback', pr, branch: prBranch, project: projMeta });
       if (item) { newWork.push(item); fixDispatched = true; }
       } // end if (!skipHumanFeedback) — cause-local guard for #2632
     }
@@ -4478,7 +4478,7 @@ async function discoverFromPrs(config, project) {
           pr_id: pr.id, pr_number: prNumber, pr_title: pr.title || '', pr_branch: prBranch,
           pr_author: pr.agent || '', pr_url: pr.url || '',
         }, `Review ${pr.id}: ${pr.title}`, {
-          dispatchKey: key, source: 'pr', pr, branch: prBranch, project: projMeta,
+          dispatchKey: key, cooldownKey: key, source: 'pr', pr, branch: prBranch, project: projMeta,
           deferReviewerResolution: true,
         });
         if (deferred) {
@@ -4492,7 +4492,7 @@ async function discoverFromPrs(config, project) {
       const item = buildPrDispatch(agentId, config, project, pr, 'review', {
         pr_id: pr.id, pr_number: prNumber, pr_title: pr.title || '', pr_branch: prBranch,
         pr_author: pr.agent || '', pr_url: pr.url || '',
-      }, `Review ${pr.id}: ${pr.title}`, { dispatchKey: key, source: 'pr', pr, branch: prBranch, project: projMeta });
+      }, `Review ${pr.id}: ${pr.title}`, { dispatchKey: key, cooldownKey: key, source: 'pr', pr, branch: prBranch, project: projMeta });
       if (item) { newWork.push(item); }
     }
 
@@ -4513,7 +4513,7 @@ async function discoverFromPrs(config, project) {
         pr_id: pr.id, pr_branch: prBranch,
         review_note: pr.minionsReview?.note || pr.reviewNote || 'See PR thread comments',
       }, `Fix ${pr.id}: ${pr.title || ''} — review feedback`, {
-        dispatchKey: key, automationCauseKey: reviewCauseKey, source: 'pr', pr, branch: prBranch, project: projMeta,
+        dispatchKey: key, cooldownKey: key, automationCauseKey: reviewCauseKey, source: 'pr', pr, branch: prBranch, project: projMeta,
         // W-mpg58wv3 — closure-loop binding. Carries the originating minion review
         // WI id (and any ADO thread ids it cited) onto the fix WI so the
         // post-completion path in lifecycle.js can auto-dispatch a re-review
@@ -4523,7 +4523,7 @@ async function discoverFromPrs(config, project) {
         addresses_threads: Array.isArray(pr.minionsReview?.threads) ? pr.minionsReview.threads.slice() : [],
       });
       if (item) {
-        newWork.push(item); setCooldown(key); fixDispatched = true;
+        newWork.push(item); fixDispatched = true;
       }
     }
 
@@ -4635,9 +4635,9 @@ async function discoverFromPrs(config, project) {
       const item = buildPrDispatch(agentId, config, project, pr, 'fix', {
         pr_id: pr.id, pr_branch: prBranch,
         review_note: reviewNote,
-      }, `Fix build failure on ${pr.id}: ${pr.title || ''}`, { dispatchKey: key, automationCauseKey: buildCauseKey, source: 'pr', pr, branch: prBranch, project: projMeta });
+      }, `Fix build failure on ${pr.id}: ${pr.title || ''}`, { dispatchKey: key, cooldownKey: key, automationCauseKey: buildCauseKey, source: 'pr', pr, branch: prBranch, project: projMeta });
       if (item) {
-        newWork.push(item); setCooldown(key); fixDispatched = true;
+        newWork.push(item); fixDispatched = true;
         try {
           const prPath = projectPrPath(project);
           mutatePullRequests(prPath, prs => {
@@ -4707,10 +4707,9 @@ async function discoverFromPrs(config, project) {
             const item = buildPrDispatch(agentId, config, project, pr, 'fix', {
               pr_id: pr.id, pr_branch: prBranch,
               review_note: `This PR has merge conflicts with the target branch. Inspect the live PR and repository history, choose the safest merge/rebase/update strategy, resolve all conflicts, validate the result, and push the branch.`,
-            }, `Fix merge conflicts on ${pr.id}: ${pr.title || ''}`, { dispatchKey: key, automationCauseKey: conflictCauseKey, source: 'pr', pr, branch: prBranch, project: projMeta });
+            }, `Fix merge conflicts on ${pr.id}: ${pr.title || ''}`, { dispatchKey: key, cooldownKey: key, automationCauseKey: conflictCauseKey, source: 'pr', pr, branch: prBranch, project: projMeta });
             if (item) {
               newWork.push(item);
-              setCooldown(key);
               // Record dispatch timestamp so re-dispatch is suppressed during ADO lag window
               try {
                 mutatePullRequests(projectPrPath(project), prs => {
@@ -5123,10 +5122,9 @@ function discoverFromWorkItems(config, project) {
       agentRole: config.agents[agentId]?.role || tempAgents.get(agentId)?.role || 'Agent',
       task: `[${project?.name || 'project'}] ${item.title || item.description?.slice(0, 80) || item.id}`,
       prompt,
-      meta: { dispatchKey: key, source: 'work-item', branch: branchName, branchStrategy: item.branchStrategy || 'parallel', useExistingBranch: !!(isPrTargeted || (item.branchStrategy === 'shared-branch' && item.featureBranch)), item: promptItem, project: { name: project?.name, localPath: project?.localPath }, deferAgentResolution: deferredAgentResolution, ...(linkedPr ? { pr: linkedPr } : {}) }
+      meta: { dispatchKey: key, cooldownKey: key, source: 'work-item', branch: branchName, branchStrategy: item.branchStrategy || 'parallel', useExistingBranch: !!(isPrTargeted || (item.branchStrategy === 'shared-branch' && item.featureBranch)), item: promptItem, project: { name: project?.name, localPath: project?.localPath }, deferAgentResolution: deferredAgentResolution, ...(linkedPr ? { pr: linkedPr } : {}) }
     });
 
-    setCooldown(key);
     } catch (err) { log('warn', `discoverFromWorkItems: skipping ${item.id}: ${err.message}`); }
   }
 
@@ -5567,7 +5565,7 @@ function discoverCentralWorkItems(config) {
           task: `[fan-out] ${item.title} → ${agent.name}${assignedProject ? ' → ' + assignedProject.name : ''}`,
           prompt,
           meta: {
-            dispatchKey: fanKey, source: 'central-work-item-fanout', item, parentKey: key,
+            dispatchKey: fanKey, cooldownKey: key, source: 'central-work-item-fanout', item, parentKey: key,
             branch: fanBranch,
             deadline: item.timeout ? Date.now() + item.timeout : Date.now() + (config.engine?.fanOutTimeout || config.engine?.agentTimeout || ENGINE_DEFAULTS.agentTimeout)
           }
@@ -5579,7 +5577,6 @@ function discoverCentralWorkItems(config) {
         scope: 'fan-out',
         fanOutAgents: idleAgents.map(a => a.id),
       });
-      setCooldown(key);
       log('info', `Fan-out: ${item.id} queued for ${idleAgents.length} agents: ${idleAgents.map(a => a.name).join(', ')}`);
 
     } else {
@@ -5793,10 +5790,8 @@ function discoverCentralWorkItems(config) {
         agentRole,
         task: item.title || item.description?.slice(0, 80) || item.id,
         prompt,
-        meta: { dispatchKey: key, source: 'central-work-item', item: { ...item, ...mutations.get(item.id) }, planFileName: item.planFile || mutations.get(item.id)?._planFileName || null, branch: centralBranch, ...(targetProject ? { project: { name: targetProject.name, localPath: targetProject.localPath } } : {}) }
+        meta: { dispatchKey: key, cooldownKey: key, source: 'central-work-item', item: { ...item, ...mutations.get(item.id) }, planFileName: item.planFile || mutations.get(item.id)?._planFileName || null, branch: centralBranch, ...(targetProject ? { project: { name: targetProject.name, localPath: targetProject.localPath } } : {}) }
       });
-
-      setCooldown(key);
     }
     } catch (err) { log('warn', `discoverCentralWorkItems: skipping ${item.id}: ${err.message}`); }
   }
@@ -6004,7 +5999,10 @@ async function discoverWork(config) {
 
   for (const item of allWork) {
     await addToDispatchWithValidation(item, { config });
-    if (item.meta?.dispatchKey) setCooldown(item.meta.dispatchKey);
+    // W-mph8xt88000ke0fc — Cooldowns are stamped by addToDispatch ONLY on
+    // successful append (post-dedup). Stamping unconditionally here used to
+    // leave orphan cooldowns for items collapsed by prDedupeKey / workItem-id
+    // / dispatchKey dedup or routed to the pre-dispatch review queue.
     if (item.meta?.source === 'pr-human-feedback') {
       clearPendingHumanFeedbackFlag(item.meta.project, item.meta.pr?.id);
     }

package/package.json

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