@yemi33/minions 0.1.2044 → 0.1.2045

package/dashboard/js/command-center.js

@@ -194,6 +194,35 @@ function _ccIsNewDashboardInstance(preRestartDashId, newDashId, clickTimeMs) {
   return Number.isFinite(parsed) && parsed > clickTimeMs;
 }
 
+// Shown when ccRestartMinions's POST to /api/dashboard/restart can't be
+// delivered — i.e. the dashboard process itself is dead, not just stale. In
+// that state the in-browser button cannot bring anything back up: a detached
+// `minions restart` child is only spawned if the POST reaches the dashboard.
+// The recovery path lives outside the browser. Surface that fact explicitly
+// instead of polling for a new dashboardStartedAt that never arrives.
+function _ccShowDashboardDeadFallback(btn, reason) {
+  var humanReason = reason || 'connection refused';
+  var msg = 'The dashboard process appears to be down — the Restart button can\'t reach it (' + humanReason + ').\n\nRun this in your terminal to recover:\n\n    minions restart';
+  if (btn) {
+    try {
+      btn.disabled = false;
+      btn.textContent = 'Run `minions restart` in terminal';
+    } catch {}
+  }
+  var copyOk = function() {
+    if (typeof showToast === 'function') showToast('cmd-toast', '`minions restart` copied — paste in your terminal', true);
+  };
+  var copyFail = function() {
+    try { window.prompt('Copy this command, then run it in your terminal:', 'minions restart'); }
+    catch { try { alert(msg); } catch {} }
+  };
+  try {
+    if (navigator.clipboard && navigator.clipboard.writeText) {
+      navigator.clipboard.writeText('minions restart').then(copyOk).catch(copyFail);
+    } else { copyFail(); }
+  } catch { copyFail(); }
+}
+
 // Triggered by the CC "Restart Minions" recovery button when a stale dashboard
 // connection is killing CC streams with "Failed to fetch". Spawns the same
 // `minions restart` flow as the CLI command (kills + respawns engine AND
@@ -242,14 +271,42 @@ async function ccRestartMinions(btn) {
     } catch { /* best-effort — clickTime fallback inside helper still covers us */ }
   }
 
-  // Fire-and-forget the restart POST. We do NOT await it — the dashboard often
-  // kills its own process before the response is flushed, so the fetch throws
-  // even though the restart child (a detached `minions restart`) is happily
-  // running. The polling loop is the source of truth for completion.
+  // Briefly await the POST so we can distinguish two failure shapes that look
+  // identical from a fire-and-forget callsite:
+  //
+  //   (a) Dashboard alive when POST landed but died mid-response. The spawned
+  //       restart child is running — polling /api/status WILL eventually see
+  //       a new dashboardStartedAt and the existing reload path works.
+  //
+  //   (b) Dashboard already dead when the user clicked. ECONNREFUSED before
+  //       any byte hits the wire. No restart child was spawned, polling would
+  //       wait the full 90 s and time out into a doomed reload (browser
+  //       lands on a port-not-listening error). This is the case operators
+  //       most often hit — the user just witnessed it today.
+  //
+  // 4 s is enough for the POST to deliver headers on a healthy box. If we
+  // saw EITHER res.ok OR a delayed-disconnect-with-headers-seen, assume the
+  // spawned child is on its way and start the polling loop. Otherwise fall
+  // back to the terminal-runnable command.
+  var postCtl = new AbortController();
+  var postTimer = setTimeout(function() { postCtl.abort(); }, 4000);
+  var postDelivered = false;
+  var postError = null;
   try {
-    fetch('/api/dashboard/restart', { method: 'POST', headers: { 'Content-Type': 'application/json' } })
-      .catch(function() { /* dashboard process likely killed mid-response — expected */ });
-  } catch { /* network layer threw before fetch even queued — also expected */ }
+    var postRes = await fetch('/api/dashboard/restart', { method: 'POST', headers: { 'Content-Type': 'application/json' }, signal: postCtl.signal });
+    if (postRes && postRes.ok) postDelivered = true;
+    else postError = 'HTTP ' + (postRes ? postRes.status : '?');
+  } catch (e) {
+    postError = String((e && e.message) || e);
+  } finally {
+    clearTimeout(postTimer);
+  }
+
+  if (!postDelivered) {
+    _ccShowDashboardDeadFallback(btn, postError);
+    return;
+  }
+
   if (btn) { try { btn.textContent = 'Restarting Minions — waiting for new dashboard...'; } catch {} }
 
   var startedAt = Date.now();

package/dashboard/js/refresh.js

@@ -71,7 +71,7 @@ const RENDER_VERSIONS = {
   projects: 1,
   notes: 1,
   prd: 1,
-  prs: 1,
+  prs: 2,
   archivedPrds: 1,
   engine: 2,
   version: 1,
@@ -206,7 +206,16 @@ function _processStatusUpdate(data) {
 
 
   // Render only changed sections
-  if (_changed('agents', data.agents)) { renderAgents(data.agents); cmdUpdateAgentList(data.agents); }
+  // Agents is exempt from the _changed gate: real-time status correctness on
+  // the Minions Members grid (status badge, running timer, Last-run line)
+  // beats the cost of re-rendering 5 cards every poll tick. The gate was
+  // causing visible staleness when the ref-eq / JSON-stringify short-circuit
+  // falsely matched across ticks (W-mpn7keq9000302c9). Still call _changed
+  // here so the _lastChangedFlags diag ring-buffer keeps recording whether
+  // the agents payload actually moved this tick.
+  _changed('agents', data.agents);
+  renderAgents(data.agents);
+  cmdUpdateAgentList(data.agents);
   if (_changed('prdProgress', data.prdProgress) || _changed('prdPrs', data.pullRequests?.length)) { renderPrdProgress(data.prdProgress); _cachePrdItems(data.prdProgress); }
   if (_changed('inbox', data.inbox)) renderInbox(data.inbox || []);
   if (_changed('projects', data.projects)) { cmdUpdateProjectList(data.projects || []); renderProjects(data.projects || []); }
@@ -343,6 +352,116 @@ let _lastStatusData = null;
 // fresh state anyway.
 let _refreshInFlight = false;
 
+// ── Dashboard-unreachable detector ───────────────────────────────────────
+// When the dashboard process dies, /api/status throws or 5xxs and the
+// existing catch block just console.errors — the page keeps painting the
+// last successful snapshot. Operators have reported the resulting symptom
+// many times: badge says "running", CC POST throws "Failed to fetch", and
+// it's not obvious the dashboard itself is dead (vs. wedged, vs. the
+// engine being down).
+//
+// Trip conditions: 2 consecutive failed polls OR >12 s since the last
+// success (3× the 4 s poll cadence, so a single flaky tick doesn't fire).
+// On trip we show a sticky red banner with two recovery actions:
+//   1. "Restart Minions"  → ccRestartMinions (works when dashboard is
+//      alive-but-stale; falls through to copy-to-clipboard when the POST
+//      itself fails)
+//   2. "Copy minions restart" → terminal fallback for the dashboard-is-
+//      truly-dead case the in-browser button can't fix on its own
+// Also overrides the engine badge to UNKNOWN/muted so the misleading
+// "RUNNING" pill stops showing while data is frozen.
+let _lastStatusOkAt = Date.now();
+let _consecutiveStatusFails = 0;
+let _unreachableSince = 0; // 0 = currently reachable
+let _unreachableAgeTimer = null;
+const _UNREACHABLE_FAIL_THRESHOLD = 2;
+const _UNREACHABLE_AGE_MS = 12000;
+
+function _formatAge(ms) {
+  if (ms < 1000) return 'just now';
+  const s = Math.round(ms / 1000);
+  if (s < 60) return s + 's ago';
+  const m = Math.floor(s / 60);
+  const rem = s % 60;
+  return rem ? m + 'm ' + rem + 's ago' : m + 'm ago';
+}
+
+function _refreshUnreachableAgeText() {
+  if (!_unreachableSince) return;
+  // The age span is rendered into the shared #engine-alert element by
+  // _markDashboardUnreachable; lookup by ID survives any inner-HTML rebuild
+  // as long as the markup keeps the span around (it does — single source).
+  const el = document.getElementById('dashboard-unreachable-age');
+  if (el) el.textContent = _formatAge(Date.now() - _lastStatusOkAt);
+}
+
+function _markDashboardUnreachable(err) {
+  if (_unreachableSince) {
+    _refreshUnreachableAgeText();
+    return;
+  }
+  _unreachableSince = Date.now();
+  window._dashboardUnreachable = {
+    since: _unreachableSince,
+    lastSuccessAt: _lastStatusOkAt,
+    lastError: String(err && err.message || err || 'unknown'),
+  };
+  // Reuse the existing #engine-alert surface (red-tinted banner already wired
+  // for engine-stale, ado-throttle, gh-throttle) instead of introducing a
+  // second red banner. Engine-stale and dashboard-unreachable are mutually
+  // exclusive in practice: engine-stale needs a fresh heartbeat from a
+  // successful poll, and a successful poll means the dashboard IS reachable.
+  // When the dashboard recovers, _markDashboardReachable hides this element
+  // explicitly; the next renderEngineAlert pass (driven by the recovered
+  // poll's engine state) then takes over normally.
+  const el = document.getElementById('engine-alert');
+  if (el) {
+    el.innerHTML =
+      '<span class="engine-alert-msg">&#x26A0;&#xFE0F; Dashboard unreachable &mdash; stale <span id="dashboard-unreachable-age">just now</span></span>' +
+      '<span class="engine-alert-action" onclick="ccRestartMinions(this)">Restart Minions</span>';
+    el.style.display = 'flex';
+  }
+  _refreshUnreachableAgeText();
+  if (_unreachableAgeTimer) clearInterval(_unreachableAgeTimer);
+  _unreachableAgeTimer = setInterval(_refreshUnreachableAgeText, 1000);
+  // Override engine badge so the cached "RUNNING" doesn't keep misleading
+  // the user. renderEngineStatus reads engine state from the next
+  // successful poll — when reachable recovers, the override clears.
+  const badge = document.getElementById('engine-badge');
+  if (badge) {
+    badge.className = 'engine-badge stopped';
+    badge.textContent = 'UNKNOWN';
+    badge.title = 'Dashboard unreachable — engine state is unknown. UI data is stale.';
+  }
+  console.warn('Dashboard unreachable:', window._dashboardUnreachable.lastError);
+}
+
+function _markDashboardReachable() {
+  if (!_unreachableSince) return;
+  const downForMs = Date.now() - _unreachableSince;
+  _unreachableSince = 0;
+  delete window._dashboardUnreachable;
+  if (_unreachableAgeTimer) { clearInterval(_unreachableAgeTimer); _unreachableAgeTimer = null; }
+  // Hand #engine-alert back to renderEngineAlert. We can't leave our content
+  // sitting in there because the next renderEngineAlert call only runs when
+  // `_changed('engine', data.engine)` returns true — if engine state hasn't
+  // shifted, our stale banner would persist past recovery.
+  const el = document.getElementById('engine-alert');
+  if (el) { el.style.display = 'none'; el.innerHTML = ''; }
+  console.log('Dashboard recovered after', _formatAge(downForMs).replace(' ago', ''));
+  // Badge restoration happens automatically on the next renderEngineStatus
+  // call (triggered by the successful refresh that brought us here).
+}
+
+// Test seam — reset detector state between scenarios.
+window._resetDashboardUnreachableForTest = function() {
+  _lastStatusOkAt = Date.now();
+  _consecutiveStatusFails = 0;
+  _unreachableSince = 0;
+  if (_unreachableAgeTimer) { clearInterval(_unreachableAgeTimer); _unreachableAgeTimer = null; }
+  delete window._dashboardUnreachable;
+};
+
 // ── Refresh diagnostics (W-mphejzx100081972) ─────────────────────────────
 // Ring buffer capturing the last 50 /api/status poll cycles so a user
 // reporting "the dashboard didn't auto-update when X changed" can paste
@@ -418,6 +537,11 @@ async function refresh() {
     const headers = {};
     if (_lastStatusEtag) headers['If-None-Match'] = _lastStatusEtag;
     const res = await safeFetch('/api/status', { headers });
+    if (!res || (!res.ok && res.status !== 304)) {
+      // Dashboard responded but with an error status. Treat as a fail tick so
+      // a 5xx-storm trips the unreachable banner just like a network error.
+      throw new Error('HTTP ' + (res ? res.status : '?'));
+    }
     let data;
     if (res.status === 304 && _lastStatusData) {
       // Cache hit — reuse last payload, skip parsing entirely.
@@ -425,6 +549,12 @@ async function refresh() {
       if (_diagEntry) {
         _diagEntry.response_status = '304';
         _diagEntry.bytes_received = 0;
+        // D2: capture etag on 304 so the diag table can show whether the
+        // server's ETag advanced even when we're reusing the cached body.
+        // Without this the "etag↓" column is blank on every 304 row and the
+        // operator can't tell server-side advancement from a pinned cache.
+        const etag304 = res.headers && (res.headers.get ? res.headers.get('etag') : null);
+        if (etag304) _diagEntry.etag_received = etag304;
       }
     } else {
       data = await res.json();
@@ -458,6 +588,12 @@ async function refresh() {
       return;
     }
     if (buildId) _knownDashboardBuildId = buildId;
+    // Successful poll — clear unreachable state. Placed AFTER the reload
+    // guards above so a dashboard restart still triggers location.reload()
+    // instead of just dismissing the banner.
+    _lastStatusOkAt = Date.now();
+    _consecutiveStatusFails = 0;
+    if (_unreachableSince) _markDashboardReachable();
     const _renderStart = _diagOn ? Date.now() : 0;
     let _diagChanges = null;
     if (_diagOn) {
@@ -484,6 +620,11 @@ async function refresh() {
       _diagEntry.response_status = (e && e.name === 'AbortError') ? 'abort' : 'error';
       _diagEntry.error_message = String((e && e.message) || e);
     }
+    _consecutiveStatusFails++;
+    const ageMs = Date.now() - _lastStatusOkAt;
+    if (_consecutiveStatusFails >= _UNREACHABLE_FAIL_THRESHOLD || ageMs > _UNREACHABLE_AGE_MS) {
+      _markDashboardUnreachable(e);
+    }
   }
   finally {
     _refreshInFlight = false;

package/dashboard/js/render-prs.js

@@ -51,22 +51,56 @@ function prRow(pr) {
   var followupChip = followupCount > 0
     ? ' <span class="pr-badge draft" style="font-size:8px" title="' + followupCount + ' follow-up work item(s) dispatched from comments on this PR">+' + followupCount + ' follow-up' + (followupCount === 1 ? '' : 's') + '</span>'
     : '';
+  const titleText = pr.title || 'Untitled';
+  const agentText = pr.agent || '—';
+  const reviewerCell = sq.reviewer && sq.status !== 'waiting'
+    ? '<span class="pr-agent" title="' + escapeHtml(sq.note || sq.reviewer) + '">' + escapeHtml(sq.reviewer) + '</span>'
+    : sq.reviewer && sq.status === 'waiting'
+      ? '<span class="pr-agent" style="color:var(--muted)" title="Vote pending confirmation">' + escapeHtml(sq.reviewer) + '…</span>'
+      : pr.reviewedBy && pr.reviewedBy.length
+        ? '<span class="pr-agent" title="' + escapeHtml(pr.reviewedBy.join(', ')) + '">' + escapeHtml(pr.reviewedBy.join(', ')) + '</span>'
+        : '<span style="color:var(--muted);font-size:11px">—</span>';
+  const createdLabel = (pr.created || '—').slice(0, 16).replace('T', ' ');
+  // Title attrs live on the inner element (link/span/badge) so hovering the
+  // ellipsis-truncated content reveals the full text. Cell tags stay bare so
+  // the header-to-cell count assertion in test/unit.test.js continues to
+  // balance.
   return '<tr>' +
-    '<td><span class="pr-id">' + escapeHtml(String(prId)) + '</span></td>' +
-    '<td><a class="pr-title" href="' + escapeHtml(safeUrl(url)) + '" target="_blank" rel="noopener">' + escapeHtml(pr.title || 'Untitled') + '</a>' + followupChip + (pr.description ? '<div class="pr-desc">' + escapeHtml(pr.description.length > 120 ? pr.description.slice(0, 120) + '...' : pr.description) + '</div>' : '') + '</td>' +
-    '<td><span class="pr-agent">' + escapeHtml(pr.agent || '—') + '</span></td>' +
+    '<td><span class="pr-id" title="' + escapeHtml(String(prId)) + '">' + escapeHtml(String(prId)) + '</span></td>' +
+    '<td><a class="pr-title" title="' + escapeHtml(titleText) + '" href="' + escapeHtml(safeUrl(url)) + '" target="_blank" rel="noopener">' + escapeHtml(titleText) + '</a>' + followupChip + (pr.description ? '<div class="pr-desc" title="' + escapeHtml(pr.description) + '">' + escapeHtml(pr.description.length > 120 ? pr.description.slice(0, 120) + '...' : pr.description) + '</div>' : '') + '</td>' +
+    '<td><span class="pr-agent" title="' + escapeHtml(agentText) + '">' + escapeHtml(agentText) + '</span></td>' +
     '<td><span class="' + branchClass + '" title="' + escapeHtml(branchError || branchLabel) + '">' + escapeHtml(branchLabel) + '</span>' + pendingReasonHtml + '</td>' +
-    '<td><span class="pr-badge ' + reviewClass + '"' + (reviewTitle ? ' title="' + escapeHtml(reviewTitle) + '"' : '') + '>' + escapeHtml(reviewLabel) + '</span></td>' +
-    '<td>' + (sq.reviewer && sq.status !== 'waiting' ? '<span class="pr-agent" title="' + escapeHtml(sq.note || '') + '">' + escapeHtml(sq.reviewer) + '</span>' : sq.reviewer && sq.status === 'waiting' ? '<span class="pr-agent" style="color:var(--muted)" title="Vote pending confirmation">' + escapeHtml(sq.reviewer) + '…</span>' : pr.reviewedBy && pr.reviewedBy.length ? '<span class="pr-agent">' + escapeHtml(pr.reviewedBy.join(', ')) + '</span>' : '<span style="color:var(--muted);font-size:11px">—</span>') + '</td>' +
-    '<td><span class="pr-badge ' + buildClass + '"' + (buildTitle ? ' title="' + escapeHtml(buildTitle) + '"' : '') + '>' + escapeHtml(buildLabel) + '</span></td>' +
-    '<td><span class="pr-badge ' + statusClass + '">' + escapeHtml(statusLabel) + '</span></td>' +
-    '<td><span class="pr-date">' + escapeHtml((pr.created || '—').slice(0, 16).replace('T', ' ')) + '</span></td>' +
+    '<td><span class="pr-badge ' + reviewClass + '" title="' + escapeHtml(reviewTitle || reviewLabel) + '">' + escapeHtml(reviewLabel) + '</span></td>' +
+    '<td>' + reviewerCell + '</td>' +
+    '<td><span class="pr-badge ' + buildClass + '" title="' + escapeHtml(buildTitle || buildLabel) + '">' + escapeHtml(buildLabel) + '</span></td>' +
+    '<td><span class="pr-badge ' + statusClass + '" title="' + escapeHtml(statusLabel) + '">' + escapeHtml(statusLabel) + '</span></td>' +
+    '<td><span class="pr-date" title="' + escapeHtml(createdLabel) + '">' + escapeHtml(createdLabel) + '</span></td>' +
     '<td><button class="pr-pager-btn" style="font-size:9px;padding:1px 5px;color:var(--red);border-color:var(--red)" data-pr-id="' + escapeHtml(String(prId)) + '" onclick="event.stopPropagation();unlinkPr(this.dataset.prId)" title="Remove from tracking">x</button></td>' +
     '</tr>';
 }
 
+// Explicit per-column widths keep the PR table from ballooning when titles or
+// branches are long. Total ≈1420px → table grows past viewport on narrow
+// windows and the .pr-table-wrap--prs container scrolls horizontally inside
+// the viewport (sticky scrollbar — see styles.css).
+const PRS_COLGROUP =
+  '<colgroup>' +
+    '<col style="width:75px">' +    // PR id
+    '<col style="width:320px">' +   // Title
+    '<col style="width:140px">' +   // Agent
+    '<col style="width:200px">' +   // Branch
+    '<col style="width:130px">' +   // Review
+    '<col style="width:140px">' +   // Signed Off By
+    '<col style="width:130px">' +   // Build
+    '<col style="width:110px">' +   // Status
+    '<col style="width:130px">' +   // Created
+    '<col style="width:50px">' +    // Actions
+  '</colgroup>';
+
 function prTableHtml(rows) {
-  return '<div class="pr-table-wrap"><table class="pr-table"><thead><tr>' +
+  return '<div class="pr-table-wrap pr-table-wrap--prs"><table class="pr-table pr-table--prs">' +
+    PRS_COLGROUP +
+    '<thead><tr>' +
     '<th>PR</th><th>Title</th><th>Agent</th><th>Branch</th><th>Review</th><th>Signed Off By</th><th>Build</th><th>Status</th><th>Created</th><th></th>' +
     '</tr></thead><tbody>' + rows + '</tbody></table></div>';
 }

package/dashboard/js/settings.js

@@ -98,6 +98,7 @@ async function openSettings() {
       settingsToggle('Auto-decompose', 'set-autoDecompose', e.autoDecompose !== false, 'Large implement items are auto-split into sub-tasks') +
       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-consolidate Memory', 'set-autoConsolidateMemory', !!e.autoConsolidateMemory, 'Periodically spawn the KB sweep (dedup + compress + normalize knowledge/) from the engine tick on a 4h cadence. Inbox→notes consolidation already runs every tick (gated by the Consolidation Threshold above); this toggle controls only the KB sweep that was previously dashboard-button-only.') +
       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 === undefined ? ((e.ccCli || e.defaultCli) === 'copilot') : !!e.ccUseWorkerPool), 'Route Command Center / doc-chat through a persistent copilot --acp worker per tab instead of spawning a fresh CLI per turn. Copilot-only (Agent Client Protocol transport); Claude does not implement ACP, so this toggle has no effect when CC runtime is Claude. Default ON for copilot (cold-spawn ~20s on Windows); forced OFF for non-copilot CC runtimes regardless of this toggle.') +
     '</div>' +
@@ -127,6 +128,7 @@ async function openSettings() {
     '<div style="display:grid;grid-template-columns:1fr 1fr;gap:8px;margin-bottom:16px">' +
       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('Agent Busy Reassign', 'set-agentBusyReassignMs', e.agentBusyReassignMs || 600000, 'ms', 'Reassign work to another agent after it waits this long on a busy agent') +
+      settingsField('Max Retries Per Agent', 'set-maxRetriesPerAgent', e.maxRetriesPerAgent ?? 2, '', 'After the same agent fails the same work item this many times, the next retry reassigns to a different eligible agent (consults routing.md + availability). Falls back to the same agent only when no alternate is available. Counted separately from total maxRetries (which still caps overall retries).') +
       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') +
     '</div>' +
@@ -606,6 +608,7 @@ async function saveSettings() {
       autoDecompose: document.getElementById('set-autoDecompose').checked,
       allowTempAgents: document.getElementById('set-allowTempAgents').checked,
       autoArchive: document.getElementById('set-autoArchive').checked,
+      autoConsolidateMemory: document.getElementById('set-autoConsolidateMemory').checked,
       autoApplyReviewVote: document.getElementById('set-autoApplyReviewVote').checked,
       autoFixBuilds: document.getElementById('set-autoFixBuilds').checked,
       autoFixConflicts: document.getElementById('set-autoFixConflicts').checked,
@@ -621,6 +624,7 @@ async function saveSettings() {
       prPollCommentsEvery: document.getElementById('set-prPollCommentsEvery').value,
       evalMaxCost: document.getElementById('set-evalMaxCost').value || null,
       agentBusyReassignMs: document.getElementById('set-agentBusyReassignMs').value,
+      maxRetriesPerAgent: document.getElementById('set-maxRetriesPerAgent').value,
       ignoredCommentAuthors: document.getElementById('set-ignoredCommentAuthors').value,
       versionCheckInterval: document.getElementById('set-versionCheckInterval').value,
       // Runtime fleet (P-7a5c1f8e). Empty strings are intentional — they signal

package/dashboard/styles.css

@@ -260,6 +260,27 @@
   .pr-table-wrap { overflow-x: auto; }
   .pr-table { width: 100%; border-collapse: collapse; font-size: var(--text-md); table-layout: auto; }
   .pr-table th:last-child, .pr-table td:last-child { width: 36px; min-width: 36px; text-align: center; }
+
+  /* PR-page table variant (W-mpmwxn9h000bd2c2): fixed column widths with
+     ellipsis overflow, and the horizontal scrollbar is pinned inside the
+     viewport via a bounded-height container on the standalone /prs page so
+     it stays reachable without scrolling to the bottom of a tall table. */
+  .pr-table--prs { table-layout: fixed; width: 100%; min-width: 1420px; }
+  .pr-table--prs th, .pr-table--prs td { overflow: hidden; text-overflow: ellipsis; }
+  .pr-table--prs th:last-child, .pr-table--prs td:last-child { width: auto; min-width: 0; }
+  .pr-table--prs .pr-title { display: block; max-width: 100%; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+  .pr-table--prs .pr-agent { display: inline-block; max-width: 100%; overflow: hidden; text-overflow: ellipsis; vertical-align: middle; white-space: nowrap; }
+  .pr-table--prs .pr-branch { max-width: 100%; }
+  .pr-table--prs .pr-desc { max-width: 100%; }
+  .pr-table--prs .pr-date { display: inline-block; max-width: 100%; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; vertical-align: middle; }
+
+  /* Standalone /prs page only: bound the table-wrap height so the horizontal
+     scrollbar (bottom of the wrap) and the table header (sticky inside the
+     wrap) stay visible while the user is on this page. The modal "see all"
+     view uses the same colgroup but is unaffected — modal-body handles its
+     own scrolling. */
+  #pr-content .pr-table-wrap--prs { max-height: calc(100vh - 200px); overflow: auto; }
+  #pr-content .pr-table--prs thead th { position: sticky; top: 0; background: var(--surface); z-index: 1; }
   .pr-table th { text-align: left; color: var(--muted); font-weight: 500; font-size: var(--text-base); text-transform: uppercase; letter-spacing: 0.5px; padding: var(--space-4) var(--space-5); border-bottom: 1px solid var(--border); }
   .pr-table td { padding: var(--space-5); border-bottom: 1px solid var(--border); vertical-align: middle; white-space: nowrap; }
   .pr-table tr:last-child td { border-bottom: none; }

package/dashboard.js

@@ -2042,6 +2042,13 @@ function _markStatusCacheBuilt() {
   _statusCacheJson = null;
   _statusCacheGzip = null;
   _statusCacheVersion++;
+  // A4: keep body.version.statusCacheVersion in sync with the ETag we're
+  // about to return. Without this, the field lags by up to 60s because
+  // `version` is built in slow-state, making refresh-diagnostics unable
+  // to distinguish "server cache pinned" from "slow-state TTL not expired."
+  if (_statusCache && _statusCache.version) {
+    _statusCache.version.statusCacheVersion = _statusCacheVersion;
+  }
 }
 
 function getStatus() {
@@ -5848,19 +5855,17 @@ const server = http.createServer(async (req, res) => {
   }
 
   async function handleKnowledgeSweep(req, res) {
-    // Source of truth = kb-sweep-state.json + PID liveness. The sweep now runs
-    // as a detached child (engine/kb-sweep-runner.js) so it survives
-    // `minions restart`; the in-memory `global._kbSweep*` flags from the old
-    // in-process implementation are gone.
+    // Source of truth = kb-sweep-state.json + PID liveness. The sweep runs as
+    // a detached child (engine/kb-sweep-runner.js) so it survives
+    // `minions restart`. The actual spawn logic lives in
+    // engine/kb-sweep.js::spawnSweepRunnerDetached — shared with the engine's
+    // auto-sweep tick phase.
     const {
-      readSweepLiveness, staleGuardMs, KB_SWEEP_STATE_PATH, KB_SWEEP_LOG_PATH, KB_SWEEP_RUNNER_PATH,
+      readSweepLiveness, staleGuardMs, spawnSweepRunnerDetached, KB_SWEEP_STATE_PATH,
     } = require('./engine/kb-sweep');
     const entryCount = ((await queries.getKnowledgeBaseEntries()) || []).length;
     const guardMs = staleGuardMs(entryCount);
 
-    // Synchronous pre-claim BEFORE awaiting the body so a concurrent POST
-    // arriving in the same tick sees in-flight state and can't double-spawn.
-    const sweepToken = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     const liveness = readSweepLiveness({ entryCount });
     if (liveness.inFlight && liveness.stale) {
       const reason = !liveness.alive
@@ -5875,79 +5880,15 @@ const server = http.createServer(async (req, res) => {
       });
     }
 
-    // Claim the slot synchronously by writing a "starting" state. The runner
-    // will overwrite this with status:'in-flight' + its real pid once it boots.
-    // readSweepLiveness grants a 15s boot-grace to "starting" records with no pid.
-    const startedAt = Date.now();
-    try {
-      safeWrite(KB_SWEEP_STATE_PATH, JSON.stringify({
-        status: 'starting', startedAt, startedAtIso: new Date().toISOString(),
-        sweepToken, pid: null,
-      }));
-    } catch (e) {
-      console.error(`[kb-sweep] failed to write starting state: ${e.message}`);
-    }
-
     const body = await readBody(req).catch(() => ({}));
-
-    // Persist body to a temp file so spawn doesn't have to serialize large
-    // pinnedKeys arrays via argv. Skip when body is empty.
-    let bodyFile = null;
-    if (body && (Array.isArray(body.pinnedKeys) || body.dryRun != null)) {
-      bodyFile = path.join(ENGINE_DIR, `tmp-kb-sweep-body-${sweepToken}.json`);
-      try { safeWrite(bodyFile, JSON.stringify(body)); }
-      catch (e) {
-        console.error(`[kb-sweep] failed to write body-file ${bodyFile}: ${e.message}`);
-        bodyFile = null;
-      }
-    }
-
-    const { spawn: cpSpawn } = require('child_process');
-    // Open log fd in append mode so spawn can pipe stdio there. Child inherits
-    // the fd; parent closes its copy after spawn returns successfully.
-    let logFdNum = null;
-    let stdio = ['ignore', 'ignore', 'ignore'];
-    try {
-      logFdNum = fs.openSync(KB_SWEEP_LOG_PATH, 'a');
-      stdio = ['ignore', logFdNum, logFdNum];
-    } catch (e) {
-      console.error(`[kb-sweep] failed to open log ${KB_SWEEP_LOG_PATH}: ${e.message}`);
-    }
-
-    const spawnArgs = ['--sweep-token', sweepToken];
-    if (bodyFile) spawnArgs.push('--body-file', bodyFile);
-
-    let proc;
-    try {
-      proc = cpSpawn(process.execPath, [KB_SWEEP_RUNNER_PATH, ...spawnArgs], {
-        cwd: MINIONS_DIR, stdio, detached: true, windowsHide: true,
-        env: { ...process.env },
-      });
-    } catch (e) {
-      if (logFdNum != null) try { fs.closeSync(logFdNum); } catch { /* ignore */ }
-      if (bodyFile) try { fs.unlinkSync(bodyFile); } catch { /* ignore */ }
-      // Release the "starting" claim on synchronous spawn failure so the user
-      // can retry immediately.
-      try { shared.safeUnlink(KB_SWEEP_STATE_PATH); } catch { /* ignore */ }
-      return jsonReply(res, 500, { error: `spawn failed: ${e.message}` });
+    const result = spawnSweepRunnerDetached({
+      pinnedKeys: Array.isArray(body?.pinnedKeys) ? body.pinnedKeys : undefined,
+      dryRun: body?.dryRun,
+    });
+    if (!result.ok) {
+      return jsonReply(res, 500, { error: result.error || 'spawn failed' });
     }
-    if (logFdNum != null) try { fs.closeSync(logFdNum); } catch { /* ignore */ }
-
-    // Conditional CAS: only update the state file from "starting" → "in-flight"
-    // if our sweepToken still owns it. If the (fast) runner already wrote
-    // "completed"/"failed" or its own "in-flight", leave that newer state alone.
-    try {
-      const current = safeJson(KB_SWEEP_STATE_PATH);
-      if (current && current.status === 'starting' && current.sweepToken === sweepToken) {
-        safeWrite(KB_SWEEP_STATE_PATH, JSON.stringify({
-          status: 'in-flight', startedAt, startedAtIso: new Date().toISOString(),
-          sweepToken, pid: proc.pid,
-        }));
-      }
-    } catch { /* best-effort */ }
-
-    proc.unref();
-    return jsonReply(res, 202, { ok: true, started: true, sweepToken });
+    return jsonReply(res, 202, { ok: true, started: true, sweepToken: result.sweepToken });
   }
 
 
@@ -8613,6 +8554,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
           versionCheckInterval: [60000],
           prPollStatusEvery: [1], prPollCommentsEvery: [1],
           agentBusyReassignMs: [0],
+          maxRetriesPerAgent: [1, 20],
         };
         for (const [key, [min, max]] of Object.entries(numericFields)) {
           if (e[key] !== undefined) {

package/docs/auto-discovery.md

@@ -1,6 +1,6 @@
 # Auto-Discovery & Execution Pipeline
 
-> Last verified: 2026-05-22 against `engine.js` `tickInner()` (lines 6068-6425).
+> Last verified: 2026-05-25 against `engine.js` `tickInner()` (lines 6293-6947) and `routing.md`.
 
 How the minions engine finds work and dispatches agents automatically.
 
@@ -199,6 +199,8 @@ routing.md table (see the file for the authoritative list):
   decompose       → ripley  (fallback: rebecca)
   meeting         → ripley  (fallback: lambert)
   docs            → lambert (fallback: _any_)
+  setup           → dallas  (fallback: _any_)
+  qa-validate     → dallas  (fallback: ralph)
 ```
 
 Resolution order:

package/docs/qa-runbook-lifecycle.md

@@ -0,0 +1,71 @@
+# QA runbook lifecycle (W-mpeiwz6k0005bf34)
+
+Validation runbooks dispatched against live managed instances. Mirrors the
+managed-spawn lifecycle (declare → engine spawns → healthcheck → observable)
+but optimized for human/agent-driven smoke + E2E flows. Surfaced on the
+`/qa` dashboard page (`dashboard/pages/qa.html`, `dashboard/js/qa.js`); full
+live-process inventory remains on `/engine` (do NOT mirror it; see
+W-mpdad3mq000m53bb).
+
+## Runbook location
+
+`qa-runbooks.json` (engine state, JSON list keyed by `id`). Each entry:
+`{ id, name, target, steps, expectedArtifacts, createdAt, createdBy }`.
+CRUD via `GET/POST /api/qa/runbooks` (POST returns the new runbook with
+engine-assigned `id`). `target` is a name from `/api/managed-processes` or
+`/api/keep-processes` (deduped by `<project>::<name>`, managed wins).
+
+## Run-record path
+
+`qa-runs.json` (newest-first, capped). Each run:
+`{ id, runbookId, runbookName, target, status, startedAt, completedAt, workItemId, agentId, artifacts }`.
+`status` ∈ `pending|dispatched|running|passed|failed|error`. Created by
+`POST /api/qa/runbooks/run` (`{ id }`), which dispatches a `qa-validate`
+work item and seeds the run with `dispatched`. Read via
+`GET /api/qa/runs?limit=50` — UI polls every 5s while the QA page is active
+and clears the interval on page navigation via the `switchPage` wrapper in
+`dashboard/js/qa.js` (matches `_stopPlanPoll`/`_stopMeetingPoll` pattern in
+`dashboard/js/state.js`).
+
+## Artifact contract
+
+`engine/qa-artifacts/<runId>/<file>`, served via
+`GET /api/qa/artifacts/<runId>/<file>`. Files are agent-uploaded screenshots,
+video recordings, and log captures listed in the run record's
+`artifacts: [{ file, kind }]`. UI auto-detects:
+`screenshot`/`png|jpg|jpeg|gif|webp|svg` → `<img>`;
+`video`/`mp4|webm|ogg|mov` → `<video controls>`; everything else → log
+preview (first 40 lines fetched lazily) with a `View full` link to the same
+endpoint. **No direct filesystem paths are exposed** — every artifact URL
+goes through `/api/qa/artifacts/` so path traversal is server-gated.
+Optional config: `engine.qaArtifactsMaxBytes` caps per-file upload size;
+when set, dashboard Settings exposes a matching toggle (CLAUDE.md
+best-practice #15).
+
+## Agent sidecar shape
+
+The `qa-validate` agent writes `agents/<id>/qa-run.json` before exit:
+
+```json
+{ "runId": "qa-run-<id>",
+  "status": "passed|failed|error",
+  "summary": "...",
+  "artifacts": [ { "file": "dashboard.png", "kind": "screenshot" },
+                 { "file": "test.log",      "kind": "log" } ],
+  "written_by": "<agentId>", "wi_id": "<workItemId>" }
+```
+
+The engine reads the sidecar in `onAgentClose`, copies the listed files into
+`engine/qa-artifacts/<runId>/`, and stamps the run record with `status`,
+`completedAt`, and the recorded `artifacts`. Sidecar validation failure is
+non-retryable (`failure_class: invalid-qa-run`); listed files outside the
+agent worktree or larger than `qaArtifactsMaxBytes` are rejected without
+stamping the run.
+
+## Entry point
+
+`playbooks/qa-validate.md`. Dispatched by `POST /api/qa/runbooks/run`;
+receives `target`, `steps`, `expectedArtifacts` as template vars; required
+to write the sidecar above before exit. Routing line in `routing.md` maps
+the synthetic `qa-validate` task-type to the playbook so manual dispatches
+work too.