@yemi33/minions 0.1.2177 → 0.1.2179

package/bin/minions.js

@@ -217,9 +217,9 @@ async function _waitForBrowserReconnect(minionsHome, { afterMs, timeoutMs = 5000
   return false;
 }
 
-function _openInBrowser(url) {
-  const result = openUrlInBrowser(url);
-  if (!result.ok) {
+function _openInBrowser(url, reason, callerHint) {
+  const result = openUrlInBrowser(url, { reason, callerHint });
+  if (!result.ok && !result.suppressed) {
     console.log(`  Could not auto-open browser: ${result.error}`);
     console.log(`  Please open ${url} manually.`);
   }
@@ -400,11 +400,15 @@ function spawnFullStackAndVerify({ rest, forceOpen, dashWasUp, restartStartMs })
     }
     console.log(`  Restart verified: engine PID ${result.engine.pid}; dashboard healthy.`);
 
-    const shouldOpen = forceOpen || !dashWasUp ||
-      !(await _waitForBrowserReconnect(MINIONS_HOME, { afterMs: restartStartMs, timeoutMs: 5000 }));
+    const shouldOpen = forceOpen || (
+      process.env.MINIONS_NO_AUTO_OPEN !== '1' && (
+        !dashWasUp ||
+        !(await _waitForBrowserReconnect(MINIONS_HOME, { afterMs: restartStartMs, timeoutMs: 5000 }))
+      )
+    );
     if (shouldOpen) {
       console.log(`  Opening dashboard in browser...`);
-      _openInBrowser(`http://localhost:${actualPort}`);
+      _openInBrowser(`http://localhost:${actualPort}`, 'cli-restart-no-beacon', 'bin/minions.js:407');
     }
     console.log('');
   })().catch(err => {
@@ -861,11 +865,20 @@ function init() {
 
   void (async () => {
     const actualPort = await _waitForDashboardPortFile(MINIONS_HOME, 8000) || upgradeRequested.port;
-    const shouldOpen = forceOpen || !dashWasUp ||
-      !(await _waitForBrowserReconnect(MINIONS_HOME, { afterMs: restartStartMs, timeoutMs: 5000 }));
+    // W-mqb9y83o — same hard kill-switch as spawnFullStackAndVerify:
+    // MINIONS_NO_AUTO_OPEN=1 in the parent env (set by the watchdog spawn
+    // and /api/dashboard/restart spawn) suppresses auto-open regardless of
+    // the beacon heuristic. `forceOpen` (`--open` / MINIONS_FORCE_OPEN=1)
+    // still wins as the explicit operator override.
+    const shouldOpen = forceOpen || (
+      process.env.MINIONS_NO_AUTO_OPEN !== '1' && (
+        !dashWasUp ||
+        !(await _waitForBrowserReconnect(MINIONS_HOME, { afterMs: restartStartMs, timeoutMs: 5000 }))
+      )
+    );
     if (shouldOpen) {
       console.log(`  Opening dashboard in browser...`);
-      _openInBrowser(`http://localhost:${actualPort}`);
+      _openInBrowser(`http://localhost:${actualPort}`, 'cli-upgrade-no-beacon', 'bin/minions.js:868');
     }
   })().catch(err => {
     console.log(`  Could not open dashboard: ${err.message}`);
@@ -1209,7 +1222,7 @@ ${fs.existsSync(path.join(PKG_ROOT, '.git')) ? `
     console.log(`\n  Minions is already running (engine PID ${enginePid}; dashboard http://localhost:${startResolved.port}).`);
     if (forceOpen) {
       console.log(`  Opening dashboard in browser...`);
-      _openInBrowser(`http://localhost:${startResolved.port}`);
+      _openInBrowser(`http://localhost:${startResolved.port}`, 'cli-start-force-open', 'bin/minions.js:1212');
     } else {
       console.log(`  Run \`minions dash\` to open the dashboard, or \`minions start --open\` to force a new browser tab.\n`);
     }
@@ -1547,7 +1560,7 @@ ${fs.existsSync(path.join(PKG_ROOT, '.git')) ? `
     handled = true;
     const url = `http://localhost:${dashResolved.port}`;
     console.log(`\n  Dashboard already running: ${url}\n`);
-    openUrlInBrowser(url);
+    openUrlInBrowser(url, { reason: 'cli-dash-warm', callerHint: 'bin/minions.js:1559' });
   });
   sock.on('error', () => {
     sock.destroy();

package/dashboard/js/command-parser.js

@@ -8,7 +8,7 @@ function cmdUpdateAgentList(agents) {
   cmdAgents = (agents || []).map(a => ({ id: a.id, name: a.name, emoji: a.emoji, role: a.role }));
 }
 function cmdUpdateProjectList(projects) {
-  cmdProjects = (projects || []).map(p => ({ name: p.name, description: p.description || '' }));
+  cmdProjects = (projects || []).map(p => ({ name: p.name, displayName: p.displayName || p.name, description: p.description || '' }));
 }
 
 function showToast(id, msg, ok, durationMs) {

package/dashboard/js/memory-panel.js

@@ -0,0 +1,262 @@
+// dashboard/js/memory-panel.js — Memory panel poller + inline SVG sparkline.
+// P-d4e5f6a7 (memory + perf audit plan, dashboard surface).
+//
+// Lifecycle: mountMemoryPanel() registers two intervals — a 10 s poll against
+// /api/diagnostics/memory for live values, and a 60 s poll against
+// /api/diagnostics/memory/history?process={engine,dashboard} for the inline
+// SVG sparkline (RSS + heapUsed over the last hour). unmountMemoryPanel()
+// clears both intervals.
+//
+// Mount/unmount registration uses the canonical PAGE_LAZY_LOADERS +
+// PAGE_LEAVE_HOOKS maps declared in state.js — engine page enter triggers
+// mount, every page-leave call triggers unmount (idempotent). state.js
+// evaluates earlier in the assembled bundle so the maps already exist when
+// this file pushes its hooks; the initial switchPage(currentPage) call at
+// the end of refresh.js (last file in the bundle) is what fires the first
+// mount when a user direct-loads /engine.
+//
+// XSS safety: nothing here writes into innerHTML / adjacent-html sinks. Live
+// values land via textContent; the sparkline is constructed via
+// createElementNS so it stays clean against eslint-plugin-no-unsanitized.
+
+const MEMORY_POLL_LIVE_MS = 10_000;
+const MEMORY_POLL_HISTORY_MS = 60_000;
+const MEMORY_SPARKLINE_WINDOW_MS = 60 * 60 * 1000; // 1 hour
+
+let _memoryPanelLiveInterval = null;
+let _memoryPanelHistoryInterval = null;
+let _memoryPanelMounted = false;
+
+function _memFmtBytes(n) {
+  if (!Number.isFinite(n)) return '—';
+  const mb = n / (1024 * 1024);
+  if (mb < 1024) return mb.toFixed(1) + ' MB';
+  return (mb / 1024).toFixed(2) + ' GB';
+}
+
+function _memFmtMs(n) {
+  if (!Number.isFinite(n)) return '—';
+  if (n < 1) return n.toFixed(2) + ' ms';
+  if (n < 100) return n.toFixed(1) + ' ms';
+  return Math.round(n) + ' ms';
+}
+
+function _memFmtUptime(seconds) {
+  if (!Number.isFinite(seconds) || seconds < 0) return '—';
+  const s = Math.floor(seconds);
+  if (s < 60) return s + 's';
+  const m = Math.floor(s / 60);
+  if (m < 60) return m + 'm ' + (s % 60) + 's';
+  const h = Math.floor(m / 60);
+  if (h < 24) return h + 'h ' + (m % 60) + 'm';
+  const d = Math.floor(h / 24);
+  return d + 'd ' + (h % 24) + 'h';
+}
+
+function _memSetText(id, val) {
+  const el = document.getElementById(id);
+  if (el) el.textContent = val;
+}
+
+function _memRenderCard(prefix, sample, stale) {
+  if (!sample) {
+    const fallback = stale ? 'stale' : '—';
+    _memSetText('memory-' + prefix + '-rss', fallback);
+    _memSetText('memory-' + prefix + '-heap', '—');
+    _memSetText('memory-' + prefix + '-external', '—');
+    _memSetText('memory-' + prefix + '-lag', '—');
+    _memSetText('memory-' + prefix + '-gc', '—');
+    _memSetText('memory-' + prefix + '-uptime', '—');
+    return;
+  }
+  _memSetText('memory-' + prefix + '-rss', _memFmtBytes(sample.rss));
+  _memSetText('memory-' + prefix + '-heap', _memFmtBytes(sample.heapUsed) + ' / ' + _memFmtBytes(sample.heapTotal));
+  _memSetText('memory-' + prefix + '-external', _memFmtBytes(sample.external));
+  _memSetText('memory-' + prefix + '-lag', _memFmtMs(sample.eventLoopLagP50) + ' / ' + _memFmtMs(sample.eventLoopLagP99));
+  const gcVal = (Number.isFinite(sample.lastGcPauseMs) && sample.lastGcPauseMs > 0)
+    ? _memFmtMs(sample.lastGcPauseMs) + (sample.lastGcKind ? ' (' + sample.lastGcKind + ')' : '')
+    : '—';
+  _memSetText('memory-' + prefix + '-gc', gcVal);
+  _memSetText('memory-' + prefix + '-uptime', _memFmtUptime(sample.uptime));
+}
+
+function _memSetStaleBadge(id, stale) {
+  const el = document.getElementById(id);
+  if (!el) return;
+  el.style.display = stale ? '' : 'none';
+}
+
+// Pure builder: returns an <svg> element rendering two polylines (RSS +
+// heapUsed) over the last MEMORY_SPARKLINE_WINDOW_MS of samples, or a
+// "no samples" label when the buffer is empty. Pure DOM via createElementNS
+// keeps eslint-plugin-no-unsanitized happy.
+function _memBuildSparkline(samples, opts) {
+  const svgNS = 'http://www.w3.org/2000/svg';
+  const width = (opts && opts.width) || 320;
+  const height = (opts && opts.height) || 60;
+  const pad = 2;
+
+  const svg = document.createElementNS(svgNS, 'svg');
+  svg.setAttribute('viewBox', '0 0 ' + width + ' ' + height);
+  svg.setAttribute('preserveAspectRatio', 'none');
+  svg.setAttribute('width', '100%');
+  svg.setAttribute('height', String(height));
+  svg.style.display = 'block';
+
+  if (!Array.isArray(samples) || samples.length === 0) {
+    const label = document.createElementNS(svgNS, 'text');
+    label.setAttribute('x', String(width / 2));
+    label.setAttribute('y', String(height / 2));
+    label.setAttribute('text-anchor', 'middle');
+    label.setAttribute('dominant-baseline', 'middle');
+    label.setAttribute('fill', 'currentColor');
+    label.setAttribute('opacity', '0.5');
+    label.setAttribute('font-size', '11');
+    label.textContent = 'no samples yet';
+    svg.appendChild(label);
+    return svg;
+  }
+
+  // Clip to the last hour, falling back to the full ring when nothing recent.
+  const now = Date.now();
+  const tMin = now - MEMORY_SPARKLINE_WINDOW_MS;
+  const windowed = samples.filter(function (s) {
+    return s && Number.isFinite(s.capturedAt) && s.capturedAt >= tMin;
+  });
+  const useSamples = windowed.length ? windowed : samples.filter(function (s) {
+    return s && Number.isFinite(s.capturedAt);
+  });
+  if (!useSamples.length) return svg;
+
+  const t0 = useSamples[0].capturedAt;
+  const t1 = useSamples[useSamples.length - 1].capturedAt;
+  const tSpan = Math.max(1, t1 - t0);
+
+  let yMin = Infinity;
+  let yMax = -Infinity;
+  for (const s of useSamples) {
+    for (const v of [s.rss, s.heapUsed]) {
+      if (Number.isFinite(v)) {
+        if (v < yMin) yMin = v;
+        if (v > yMax) yMax = v;
+      }
+    }
+  }
+  if (!Number.isFinite(yMin) || !Number.isFinite(yMax)) { yMin = 0; yMax = 1; }
+  const ySpan = Math.max(1, yMax - yMin);
+
+  function _series(field) {
+    const pts = [];
+    for (const s of useSamples) {
+      const v = s[field];
+      if (!Number.isFinite(v)) continue;
+      const x = pad + ((s.capturedAt - t0) / tSpan) * (width - 2 * pad);
+      const y = height - pad - ((v - yMin) / ySpan) * (height - 2 * pad);
+      pts.push(x.toFixed(1) + ',' + y.toFixed(1));
+    }
+    return pts.join(' ');
+  }
+
+  function _addLine(field, color) {
+    const pts = _series(field);
+    if (!pts) return;
+    const line = document.createElementNS(svgNS, 'polyline');
+    line.setAttribute('points', pts);
+    line.setAttribute('fill', 'none');
+    line.setAttribute('stroke', color);
+    line.setAttribute('stroke-width', '1.5');
+    line.setAttribute('vector-effect', 'non-scaling-stroke');
+    svg.appendChild(line);
+  }
+
+  _addLine('rss', 'var(--blue, #4ea1ff)');
+  _addLine('heapUsed', 'var(--green, #4caf50)');
+  return svg;
+}
+
+function _memRenderSparkline(containerId, samples) {
+  const el = document.getElementById(containerId);
+  if (!el) return;
+  const width = el.clientWidth || 320;
+  const svg = _memBuildSparkline(samples, { width, height: 60 });
+  el.replaceChildren(svg);
+}
+
+async function _memRefreshLive() {
+  let data;
+  try {
+    const res = await fetch('/api/diagnostics/memory');
+    if (!res.ok) return;
+    data = await res.json();
+  } catch {
+    return; // network blip — leave previous values in place
+  }
+  if (!data || typeof data !== 'object') return;
+  _memRenderCard('engine', data.engine, !!data.engineStale);
+  _memRenderCard('dashboard', data.dashboard, false);
+  _memSetStaleBadge('memory-engine-stale-badge', !!data.engineStale);
+}
+
+async function _memRefreshHistory() {
+  await Promise.all(['engine', 'dashboard'].map(async function (proc) {
+    try {
+      const res = await fetch('/api/diagnostics/memory/history?process=' + encodeURIComponent(proc));
+      if (!res.ok) return;
+      const data = await res.json();
+      const samples = (data && Array.isArray(data.samples)) ? data.samples : [];
+      _memRenderSparkline('memory-' + proc + '-sparkline', samples);
+    } catch {
+      // network blip — keep the previous sparkline
+    }
+  }));
+}
+
+function mountMemoryPanel() {
+  if (_memoryPanelMounted) return;
+  // No-op when the engine page hasn't been assembled yet (defensive — the
+  // fragment is always part of the bundle, but this keeps the hook safe
+  // against partial DOM states during test harnesses).
+  if (!document.getElementById('memory-panel-content')) return;
+  _memoryPanelMounted = true;
+  _memRefreshLive();
+  _memRefreshHistory();
+  _memoryPanelLiveInterval = setInterval(_memRefreshLive, MEMORY_POLL_LIVE_MS);
+  _memoryPanelHistoryInterval = setInterval(_memRefreshHistory, MEMORY_POLL_HISTORY_MS);
+}
+
+function unmountMemoryPanel() {
+  if (!_memoryPanelMounted) return;
+  _memoryPanelMounted = false;
+  if (_memoryPanelLiveInterval) {
+    clearInterval(_memoryPanelLiveInterval);
+    _memoryPanelLiveInterval = null;
+  }
+  if (_memoryPanelHistoryInterval) {
+    clearInterval(_memoryPanelHistoryInterval);
+    _memoryPanelHistoryInterval = null;
+  }
+}
+
+// Register the lifecycle hooks against the canonical maps in state.js.
+// `const` declarations don't block mutating the underlying object/array,
+// so we can splice in our entries without editing state.js. Best-effort:
+// any failure leaves the panel unmounted but does not break navigation.
+try {
+  if (typeof PAGE_LAZY_LOADERS === 'object' && PAGE_LAZY_LOADERS) {
+    if (!Array.isArray(PAGE_LAZY_LOADERS.engine)) PAGE_LAZY_LOADERS.engine = [];
+    if (PAGE_LAZY_LOADERS.engine.indexOf('mountMemoryPanel') < 0) {
+      PAGE_LAZY_LOADERS.engine.push('mountMemoryPanel');
+    }
+  }
+  if (typeof PAGE_LEAVE_HOOKS !== 'undefined' && Array.isArray(PAGE_LEAVE_HOOKS)) {
+    if (PAGE_LEAVE_HOOKS.indexOf('unmountMemoryPanel') < 0) {
+      PAGE_LEAVE_HOOKS.push('unmountMemoryPanel');
+    }
+  }
+} catch { /* registration is best-effort */ }
+
+window.MinionsMemoryPanel = {
+  mountMemoryPanel,
+  unmountMemoryPanel,
+  _buildSparkline: _memBuildSparkline,
+};

package/dashboard/js/qa.js

@@ -620,7 +620,7 @@ async function loadQaProjectsSelect() {
       const res = await fetch('/api/status');
       const json = res.ok ? await res.json() : {};
       if (Array.isArray(json && json.projects)) {
-        projects = json.projects.map(p => ({ name: p.name, description: p.description || '' }));
+        projects = json.projects.map(p => ({ name: p.name, displayName: p.displayName || p.name, description: p.description || '' }));
       }
     }
   } catch { projects = []; }
@@ -631,7 +631,7 @@ async function loadQaProjectsSelect() {
     if (!p || !p.name) continue;
     const opt = document.createElement('option');
     opt.value = p.name;
-    opt.textContent = p.name;
+    opt.textContent = p.displayName || p.name;
     if (previouslySelected.has(p.name)) opt.selected = true;
     sel.appendChild(opt);
   }

package/dashboard/js/refresh.js

@@ -134,7 +134,7 @@ const RENDER_VERSIONS = {
   prdProgress: 1,
   prdPrs: 1,
   inbox: 2,
-  projects: 1,
+  projects: 2,
   notes: 1,
   prd: 1,
   prs: 3,
@@ -143,6 +143,7 @@ const RENDER_VERSIONS = {
   version: 1,
   adoThrottle: 1,
   ghThrottle: 1,
+  pausedBanner: 1,
   dispatch: 2,
   engineLog: 2,
   metrics: 1,
@@ -713,6 +714,13 @@ function _processStatusUpdate(data, opts) {
   _safeRender('adoThrottle', function() { renderAdoThrottleAlert(data.adoThrottle); });
   _changed('ghThrottle', data.ghThrottle);
   _safeRender('ghThrottle', function() { renderGhThrottleAlert(data.ghThrottle); });
+  // P-g7a2b4c5 — sticky kill-switch banner. Cache key is the pair of paused
+  // flags so the banner only re-renders when either flag actually flips (the
+  // full data.engine slice changes every tick because heartbeat/lastTickAt
+  // advance).
+  const _pausedCacheKey = (data.engine && (data.engine.pollingPaused ? 'p' : '-') + (data.engine.autoFixPaused ? 'a' : '-')) || '--';
+  _changed('pausedBanner', _pausedCacheKey);
+  _safeRender('pausedBanner', function() { renderPausedBanner(data.engine); });
   // Dispatch now comes from /api/dispatch — a dedicated fresh-JSON
   // endpoint that re-runs getDispatchQueue() server-side on every
   // request (issue #2949). Completion-report sidecars are now loaded

package/dashboard/js/render-dispatch.js

@@ -245,6 +245,98 @@ function renderGhThrottleAlert(ghThrottle) {
   el.style.display = 'flex';
 }
 
+// P-g7a2b4c5 — Sticky cross-page kill-switch banner. Renders whenever either
+// engine.pollingPaused or engine.autoFixPaused is true, with per-row Resume
+// buttons that POST to the convenience endpoints from P-f3c9d0e7. Built with
+// the DOM API (no innerHTML) so the eslint-plugin-no-unsanitized gate passes
+// cleanly — banner content is system-controlled but follows the project
+// convention of avoiding innerHTML in new code anyway.
+function renderPausedBanner(engine) {
+  const el = document.getElementById('paused-banner');
+  if (!el) return;
+  const pollingPaused = !!(engine && engine.pollingPaused);
+  const autoFixPaused = !!(engine && engine.autoFixPaused);
+  if (!pollingPaused && !autoFixPaused) {
+    el.hidden = true;
+    while (el.firstChild) el.removeChild(el.firstChild);
+    return;
+  }
+
+  // Wipe + rebuild — list-of-pauses model, one row per active pause.
+  while (el.firstChild) el.removeChild(el.firstChild);
+  el.hidden = false;
+
+  const title = document.createElement('div');
+  title.className = 'paused-banner-title';
+  title.textContent = '⚠️ Some engine functions are paused:';
+  el.appendChild(title);
+
+  const list = document.createElement('ul');
+  list.className = 'paused-banner-list';
+  el.appendChild(list);
+
+  const rows = [];
+  if (pollingPaused) {
+    rows.push({
+      key: 'polling',
+      label: 'Polling',
+      detail: 'no new PR state arriving',
+      endpoint: '/api/engine/polling/resume',
+    });
+  }
+  if (autoFixPaused) {
+    rows.push({
+      key: 'autofix',
+      label: 'PR auto-fix',
+      detail: 'no new PR-triggered dispatches',
+      endpoint: '/api/engine/auto-fix/resume',
+    });
+  }
+
+  rows.forEach(function (row) {
+    const li = document.createElement('li');
+    li.className = 'paused-banner-row';
+    li.setAttribute('data-paused-row', row.key);
+
+    const labelSpan = document.createElement('span');
+    labelSpan.className = 'paused-banner-row-label';
+    labelSpan.textContent = '• ' + row.label;
+    li.appendChild(labelSpan);
+
+    const detailSpan = document.createElement('span');
+    detailSpan.className = 'paused-banner-row-detail';
+    detailSpan.textContent = '— ' + row.detail;
+    li.appendChild(detailSpan);
+
+    const btn = document.createElement('button');
+    btn.type = 'button';
+    btn.className = 'paused-banner-row-resume';
+    btn.textContent = 'Resume';
+    btn.setAttribute('data-paused-resume', row.key);
+    btn.addEventListener('click', function () {
+      if (btn.disabled) return;
+      btn.disabled = true;
+      btn.classList.add('clicked');
+      fetch(row.endpoint, { method: 'POST', headers: { 'Content-Type': 'application/json' } })
+        .then(function (resp) {
+          if (!resp.ok) throw new Error('HTTP ' + resp.status);
+          if (typeof showToast === 'function') showToast('cmd-toast', row.label + ' resumed', true);
+          if (typeof refreshNow === 'function') refreshNow();
+        })
+        .catch(function (err) {
+          btn.disabled = false;
+          btn.classList.remove('clicked');
+          if (typeof showToast === 'function') {
+            showToast('cmd-toast', 'Resume failed: ' + (err && err.message ? err.message : 'unknown'), false);
+          }
+        });
+    });
+    li.appendChild(btn);
+
+    list.appendChild(li);
+  });
+}
+
 function renderDispatch(dispatch, opts) {
   opts = opts || {};
   if (!dispatch) return;

package/dashboard/js/render-other.js

@@ -12,7 +12,7 @@ function renderProjects(projects) {
   // eslint-disable-next-line no-unsanitized/property -- reason: structural HTML is a string literal; all user data wrapped in escHtml() (fields: project name, path, branch metadata)
   list.innerHTML = visible.map(p =>
     '<span data-project="' + escHtml(p.name) + '" title="' + escHtml(p.path || '') + '" style="display:inline-flex;align-items:center;gap:6px;background:var(--surface2);border:1px solid var(--border);border-radius:4px;padding:3px 10px;color:var(--blue);font-weight:500;cursor:help">' +
-      escHtml(p.name) +
+      escHtml(p.displayName || p.name) +
       _renderProjectBranch(p) +
       '<span onclick="event.stopPropagation();projectChipRemove(\'' + escHtml(p.name) + '\')" title="Remove project (cancels pending work, archives data dir)" style="color:var(--muted);font-weight:600;cursor:pointer;padding:0 2px;line-height:1" onmouseover="this.style.color=\'var(--red)\'" onmouseout="this.style.color=\'var(--muted)\'">&times;</span>' +
     '</span>'