@yemi33/minions 0.1.2178 → 0.1.2180

package/README.md

@@ -57,7 +57,7 @@ node ~/.minions/minions.js init
 | `minions remove <dir-or-name> [--keep-data \| --purge --force]` | Unlink a project: cancels pending work items, drains dispatch + kills active agents, cleans worktrees, disables linked schedules, archives `projects/<name>/` to `projects/.archived/<name>-YYYYMMDD/`. Use `--keep-data` to leave the data dir in place, or `--purge --force` to delete it. |
 | `minions list` | List all linked projects with descriptions |
 | `minions restart` | Start engine and dashboard together (recommended after reboot) |
-| `minions start` | Start engine daemon (ticks every 10s, auto-syncs MCP servers) |
+| `minions start` | Start engine daemon (ticks every 10s) |
 | `minions stop` | Stop the engine |
 | `minions status` | Show agents, projects, dispatch queue, quality metrics |
 | `minions pause` / `resume` | Pause/resume dispatching |
@@ -71,7 +71,7 @@ node ~/.minions/minions.js init
 | `minions kill` | Kill all active agents and reset their dispatches to pending |
 | `minions complete <dispatch-id>` | Manually mark a dispatch as completed |
 | `minions config set-cli <R> [--model M]` | Persist the default runtime/model without starting the engine |
-| `minions mcp-sync` | Sync MCP servers from `~/.claude.json` |
+| `minions mcp-sync` | Print harness propagation diagnostic (read-only; same source as `minions doctor --harness`) |
 | `minions cleanup` | Run cleanup manually (temp files, worktrees, zombies) |
 | `minions dash` | Open dashboard (starts if not already running, port 7331) |
 | `minions nuke --confirm` | Factory reset runtime state and reset config to defaults |
@@ -322,9 +322,11 @@ When dispatching agents, the engine reads each project's `CLAUDE.md` and injects
 
 Agents need repo-host tooling to create PRs, post review comments, check status, and handle review feedback. GitHub repos use `gh`. Azure DevOps repos should use the `az` CLI first and keep the Azure DevOps MCP server available only as a fallback when `az` is unavailable or does not support the required operation.
 
-Agents inherit MCP servers directly from `~/.claude.json` as Claude Code processes — add fallback servers there and they're immediately available to all agents on next spawn.
+Agents inherit MCP servers, skills, and slash-commands directly from each runtime's native config — Claude reads `~/.claude.json` + `~/.claude/{skills,commands}/`, Copilot reads `~/.copilot/` + `~/.agents/`, Codex reads `~/.codex/`. Add fallback servers, skills, or commands there and they're immediately available to all agents on next spawn. No sync step is required.
 
-Manually refresh with `minions mcp-sync`.
+**What your agent sees.** On every dispatch, the engine merges three layers around the agent's worktree: (1) **user-scope** MCP servers, skills, and slash-commands from the runtime's home dir (e.g. `~/.claude/`, `~/.copilot/`); (2) **project-scope** equivalents from `<repo>/.claude/`, `<repo>/.copilot/`, `<repo>/.mcp.json` — propagated even when the worktree is on a different branch than your live checkout (gate: `engine.harnessPropagateProjectLocal`, default on); (3) **workspace MCPs** from the worktree's `.mcp.json`, pre-approved for Claude so the agent never has to prompt (gate: `engine.claudePreApproveWorkspaceMcps`, default on). Per-agent opt-out via `agent.hermeticHarness: true` (or fleet-wide `engine.hermeticHarness: true`) strips everything except `minionsDir`, giving you a known-empty harness for reproducible runs.
+
+To audit which propagation surfaces (asset dirs, skill roots, slash-command dirs, MCP config files) each runtime sees on this host, run `minions mcp-sync` (or `minions doctor --harness` for the same diagnostic with a non-zero exit on registry errors). Both commands are read-only — they print the per-runtime survey without mutating any state. See [docs/harness-propagation.md](docs/harness-propagation.md) for the propagation contract.
 
 ### GitHub Users
 
@@ -346,7 +348,7 @@ az login
 az devops configure --defaults organization=https://dev.azure.com/YOUR_ORG project=YOUR_PROJECT
 ```
 
-Optionally add the [Azure DevOps MCP server](https://github.com/microsoft/azure-devops-mcp) to your Claude Code settings (`~/.claude.json`) as a fallback. The engine will auto-sync it to all agents on next start.
+Optionally add the [Azure DevOps MCP server](https://github.com/microsoft/azure-devops-mcp) to your Claude Code settings (`~/.claude.json`) as a fallback. Agents inherit it on next spawn — no sync step needed.
 
 ## Work Items
 

package/bin/minions.js

@@ -10,7 +10,7 @@
  *   minions list                     List linked projects
  *   minions update [--no-wait]       Update to latest version (--no-wait backgrounds the post-update restart)
  *   minions version                  Show installed and package versions
- *   minions doctor                   Check prerequisites and runtime health
+ *   minions doctor [--harness]       Check prerequisites and runtime health (--harness: print harness propagation diagnostic)
  *   minions restart [--open]         Stop + start engine + dashboard (--open forces a new browser tab)
  *   minions start [--open]           Start engine + dashboard if not already running (no-op when up)
  *   minions stop                     Stop the engine
@@ -29,7 +29,7 @@
  *   minions config set-cli <R> [--model M]  Persist default runtime/model
  *   minions bridge <subcmd>          Constellation bridge: status|health|enable|disable
  *   minions plan <file|text> [proj]  Run a plan
- *   minions mcp-sync                 Sync MCP servers from ~/.claude.json
+ *   minions mcp-sync                 Print harness propagation diagnostic (read-only; same source as `doctor --harness`)
  *   minions nuke --confirm           Factory reset runtime state/config
  *   minions uninstall --confirm      Remove Minions and uninstall package
  */
@@ -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}`);
@@ -1087,7 +1100,7 @@ if (!cmd || cmd === 'help' || cmd === '--help' || cmd === '-h') {
     minions init                     Bootstrap ~/.minions/ (first time)
     minions update [--no-wait]       Update to latest version (--no-wait backgrounds the restart)
     minions version                  Show installed vs package version
-    minions doctor                   Check prerequisites and runtime health
+    minions doctor [--harness]       Check prerequisites and runtime health (--harness: print harness propagation diagnostic)
     minions add <project-dir>        Link a project (interactive)
     minions remove <project-dir>     Unlink a project
     minions list                     List linked projects
@@ -1110,7 +1123,7 @@ if (!cmd || cmd === 'help' || cmd === '--help' || cmd === '-h') {
     minions config set-cli <R> [--model M]
                                       Persist default runtime/model without starting
     minions bridge <subcmd>          Constellation bridge: status|health|enable|disable
-    minions mcp-sync                 Sync MCP servers from ~/.claude.json
+    minions mcp-sync                 Print harness propagation diagnostic (read-only; same source as 'doctor --harness')
     minions cleanup                  Clean temp files, worktrees, zombies
     minions pr comment <repo> <n>    Post a marker-prepended PR comment via gh
                                        --agent <id> --kind <k> [--wi <id>] (--body-file <f> | --body <text>)
@@ -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`);
     }
@@ -1437,8 +1450,17 @@ ${fs.existsSync(path.join(PKG_ROOT, '.git')) ? `
   console.log('    npm install -g @yemi33/minions && minions init\n');
 } else if (cmd === 'doctor') {
   ensureInstalled();
-  const { doctor } = require(path.join(MINIONS_HOME, 'engine', 'preflight'));
-  doctor(MINIONS_HOME).then(ok => process.exit(ok ? 0 : 1));
+  const { doctor, runHarnessDoctor } = require(path.join(MINIONS_HOME, 'engine', 'preflight'));
+  if (rest.includes('--harness')) {
+    // P-a3f9b2c1 — print the harness propagation diagnostic and exit. The
+    // legacy `minions doctor` still runs the full preflight + runtime fleet
+    // sweep; `--harness` is a one-shot survey of the asset-propagation
+    // surfaces only (see docs/harness-propagation.md).
+    const ok = runHarnessDoctor(MINIONS_HOME);
+    process.exit(ok ? 0 : 1);
+  } else {
+    doctor(MINIONS_HOME).then(ok => process.exit(ok ? 0 : 1));
+  }
 } else if (cmd === 'watchdog') {
   // External recovery scheduled by the OS. Survives cluster-kill scenarios
   // the in-process supervisor can't (Windows job-object teardown when the
@@ -1547,7 +1569,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,324 @@
+// 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
+    }
+  }));
+}
+
+// P-e5f6a7b8 — operator-driven heap snapshot capture button. Gates the
+// POST behind a window.confirm() that calls out the multi-second stall
+// and the 50–200 MB per-process disk write. Renders the resulting paths
+// (and any engine timeout) into #memory-heap-snapshot-result via
+// textContent so the XSS gate remains clean.
+const HEAP_SNAPSHOT_CONFIRM_TOKEN = 'YES_I_UNDERSTAND_THIS_STALLS_THE_ENGINE';
+const HEAP_SNAPSHOT_CONFIRM_MSG =
+  'Capture a heap snapshot from BOTH the engine and dashboard processes?\n\n' +
+  '⚠️ Each process will be stalled for several seconds and will write a 50–200 MB ' +
+  '.heapsnapshot file under engine/diagnostics/. Only do this when actively ' +
+  'debugging a leak. Rate-limited to 1 capture per 60 seconds.';
+
+function _memSetHeapResult(text) {
+  const el = document.getElementById('memory-heap-snapshot-result');
+  if (el) el.textContent = text;
+}
+
+async function _memCaptureHeapSnapshot() {
+  const btn = document.getElementById('memory-heap-snapshot-btn');
+  if (typeof window !== 'undefined' && typeof window.confirm === 'function') {
+    if (!window.confirm(HEAP_SNAPSHOT_CONFIRM_MSG)) return;
+  }
+  if (btn) { btn.disabled = true; }
+  _memSetHeapResult('Capturing… (engine + dashboard each stall for several seconds)');
+  try {
+    const res = await fetch(
+      '/api/diagnostics/heap-snapshot?confirm=' + encodeURIComponent(HEAP_SNAPSHOT_CONFIRM_TOKEN),
+      { method: 'POST' });
+    let data = null;
+    try { data = await res.json(); } catch { /* empty body */ }
+    if (!res.ok) {
+      const msg = (data && (data.error || data.hint)) || ('HTTP ' + res.status);
+      _memSetHeapResult('Capture failed: ' + msg);
+      return;
+    }
+    const lines = [];
+    lines.push('Dashboard snapshot: ' + (data && data.dashboardSnapshot ? data.dashboardSnapshot : '(none)'));
+    if (data && data.engineTimedOut) {
+      lines.push('Engine snapshot:    TIMED OUT after ' + ((data.timeoutMs || 30000) / 1000) + 's ' +
+        '— the engine may have captured it after the dashboard gave up; check engine/diagnostics/.');
+    } else {
+      lines.push('Engine snapshot:    ' + (data && data.engineSnapshot ? data.engineSnapshot : '(none)'));
+    }
+    lines.push('');
+    lines.push('Load these in Chrome DevTools → Memory → Load to inspect.');
+    _memSetHeapResult(lines.join('\n'));
+  } catch (e) {
+    _memSetHeapResult('Capture failed: ' + (e && e.message ? e.message : String(e)));
+  } finally {
+    if (btn) { btn.disabled = false; }
+  }
+}
+
+function _memWireHeapSnapshotButton() {
+  const btn = document.getElementById('memory-heap-snapshot-btn');
+  if (!btn || btn.dataset.heapSnapshotWired === '1') return;
+  btn.dataset.heapSnapshotWired = '1';
+  btn.addEventListener('click', _memCaptureHeapSnapshot);
+}
+
+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);
+  _memWireHeapSnapshotButton();
+}
+
+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,
+  _captureHeapSnapshot: _memCaptureHeapSnapshot,
+};

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,
@@ -149,7 +149,9 @@ const RENDER_VERSIONS = {
   metrics: 1,
   workItems: 3,
   skills: 1,
+  commands: 1,
   mcpServers: 1,
+  harnessDiag: 1,
   schedules: 1,
   watches: 2,
   meetings: 1,
@@ -854,8 +856,24 @@ function _processStatusUpdate(data, opts) {
   });
   _changed('skills', data.skills);
   _safeRender('skills', function() { renderSkills(data.skills || []); });
+  _changed('commands', data.commands);
+  _safeRender('commands', function() { renderCommands(data.commands || []); });
   _changed('mcpServers', data.mcpServers);
   _safeRender('mcpServers', function() { renderMcpServers(data.mcpServers || []); });
+  // Harness propagation diagnostic comes from /api/harness/diagnostics
+  // (rare-change, fetched on each /api/status refresh so the tools page is
+  // always up to date when an operator drops a project-local skill).
+  _safeRender('harnessDiag', function() {
+    fetch('/api/harness/diagnostics')
+      .then(function (r) { return r.ok ? r.json() : Promise.reject(); })
+      .then(function (fresh) {
+        window._lastHarnessDiag = fresh;
+        _safeRender('harnessDiag', function() { renderHarnessDiagnostics(fresh); });
+      })
+      .catch(function () {
+        if (window._lastHarnessDiag) _safeRender('harnessDiag', function() { renderHarnessDiagnostics(window._lastHarnessDiag); });
+      });
+  });
   // Schedule definitions stay on /api/status (config-derived), but the
   // _lastRun/_lastResult overlay is re-applied client-side from
   // /state/engine/schedule-runs.json so a freshly-fired schedule lights up