@yemi33/minions 0.1.2308 → 0.1.2310

package/bin/minions.js

@@ -391,6 +391,19 @@ function _resolveRestartHealthTimeoutMs() {
   return Math.min(300000, Math.max(15000, resolved));
 }
 
+/**
+ * Read config.json best-effort for callers that spawn engine.js before any
+ * config is loaded into memory. Mirrors _resolveRestartHealthTimeoutMs's
+ * inline read.
+ */
+function _readConfigJsonSafe() {
+  const home = process.env.MINIONS_HOME || (typeof MINIONS_HOME !== 'undefined' ? MINIONS_HOME : null);
+  try {
+    if (home) return JSON.parse(fs.readFileSync(path.join(home, 'config.json'), 'utf8'));
+  } catch { /* config may not exist yet */ }
+  return null;
+}
+
 /**
  * Spawn engine + dashboard + supervisor, verify health, optionally open browser.
  * Shared by `minions start` and `minions restart` — restart layers a kill phase
@@ -401,8 +414,14 @@ function _resolveRestartHealthTimeoutMs() {
 function spawnFullStackAndVerify({ rest, forceOpen, dashWasUp, restartStartMs }) {
   const engineOut = _openStdioLog('engine-stdio.log');
   const engineErr = _openStdioLog('engine-stdio.log');
+  // W-mr2c4i8m0004da94: enable Node's crash-diagnostics report for the
+  // engine.js process so a future silent death (the class investigated in
+  // W-mr2azk6i) leaves a JSON report under engine/diagnostics/crash-reports
+  // instead of vanishing with no trace.
+  const crashDiagEnv = shared.getEngineCrashDiagnosticsEnv(_readConfigJsonSafe());
   const engineProc = spawn(process.execPath, [..._sqliteSpawnFlags(), path.join(MINIONS_HOME, 'engine.js'), 'start', ...rest], {
-    cwd: MINIONS_HOME, stdio: ['ignore', engineOut, engineErr], detached: true, windowsHide: true
+    cwd: MINIONS_HOME, stdio: ['ignore', engineOut, engineErr], detached: true, windowsHide: true,
+    env: { ...process.env, ...crashDiagEnv }
   });
   engineProc.unref();
   console.log(`\n  Engine started (PID: ${engineProc.pid})`);
@@ -934,7 +953,8 @@ function init() {
     ? `\n  Upgrade complete (${pkgVersion}). Restarting engine and dashboard...\n`
     : '\n  Starting engine and dashboard...\n');
   const engineProc = spawn(process.execPath, [..._sqliteSpawnFlags(), path.join(MINIONS_HOME, 'engine.js'), 'start'], {
-    cwd: MINIONS_HOME, stdio: 'ignore', detached: true, windowsHide: true
+    cwd: MINIONS_HOME, stdio: 'ignore', detached: true, windowsHide: true,
+    env: { ...process.env, ...shared.getEngineCrashDiagnosticsEnv(_readConfigJsonSafe()) }
   });
   engineProc.unref();
   console.log(`  Engine started (PID: ${engineProc.pid})`);

package/dashboard/js/refresh.js

@@ -135,7 +135,8 @@ const RENDER_VERSIONS = {
   prdPrs: 1,
   inbox: 2,
   // Bumped 4→5 for the clickable checkout-mode pill + picker (W-mr1b67zi0006b788).
-  projects: 5,
+  // Bumped 5→6 for multi-select hybrid liveValidation.type support (W-mr2m1ute000a9c01).
+  projects: 6,
   notes: 1,
   prd: 3,
   prs: 3,

package/dashboard/js/render-other.js

@@ -108,9 +108,11 @@ function _renderWorktreeModePill(p) {
   const name = escHtml(p.name);
   const common = ' data-checkout-pill="' + name + '" role="button" tabindex="0" aria-haspopup="true" aria-label="Change checkout mode"';
   if (p.checkoutMode === 'live') {
-    if (p.liveValidationType) {
-      const vt = escapeHtml(p.liveValidationType);
-      return ' <span class="project-mode-pill project-mode-hybrid project-mode-pill-clickable"' + common + ' title="Hybrid live-validation — coding work items author in isolated worktrees; only the &quot;' + vt + '&quot; validation type runs in-place on the live checkout (capped to one mutating dispatch, refused on a dirty tree). Click to change.">⚡ Hybrid · ' + vt + '</span>';
+    const types = _liveValidationTypesArray(p);
+    if (types.length > 0) {
+      const typesText = types.join(', ');
+      const vt = escapeHtml(typesText);
+      return ' <span class="project-mode-pill project-mode-hybrid project-mode-pill-clickable"' + common + ' title="Hybrid live-validation — coding work items author in isolated worktrees; only the &quot;' + vt + '&quot; validation type(s) run in-place on the live checkout (capped to one mutating dispatch, refused on a dirty tree). Click to change.">⚡ Hybrid · ' + vt + '</span>';
     }
     return ' <span class="project-mode-pill project-mode-live project-mode-pill-clickable"' + common + ' title="Live-checkout dispatch mode — agents run in-place inside the project working tree (no isolated worktree); capped to one mutating dispatch and refused on a dirty tree. Click to change.">⚡ Live checkout</span>';
   }
@@ -130,6 +132,16 @@ function _findProjectInLastStatus(name) {
   return projects.find(function(p) { return p.name === name; }) || null;
 }
 
+// Normalize p.liveValidationType (single string legacy shape, OR array of
+// strings — W-mr2m1ute000a9c01 multi-select) into an array of non-empty
+// strings for uniform handling by menu/pill rendering code.
+function _liveValidationTypesArray(p) {
+  const raw = p && p.liveValidationType;
+  if (!raw) return [];
+  const arr = Array.isArray(raw) ? raw : [raw];
+  return arr.filter(function(t) { return typeof t === 'string' && t.length > 0; });
+}
+
 function _closeCheckoutModeMenu() {
   const existing = document.getElementById('checkout-mode-menu');
   if (existing) existing.remove();
@@ -183,8 +195,8 @@ function _openCheckoutModeMenu(projectName, anchorEl) {
       item.appendChild(desc);
     }
     const isActive = (mode === 'worktree' && project.checkoutMode !== 'live')
-      || (mode === 'live' && project.checkoutMode === 'live' && !project.liveValidationType)
-      || (mode === 'hybrid' && project.checkoutMode === 'live' && !!project.liveValidationType);
+      || (mode === 'live' && project.checkoutMode === 'live' && _liveValidationTypesArray(project).length === 0)
+      || (mode === 'hybrid' && project.checkoutMode === 'live' && _liveValidationTypesArray(project).length > 0);
     if (isActive) {
       item.setAttribute('aria-checked', 'true');
       item.classList.add('checkout-mode-menu-item-active');
@@ -221,9 +233,12 @@ function _openCheckoutModeMenu(projectName, anchorEl) {
   if (first) first.focus();
 }
 
-// Second step of the picker for hybrid mode: pick which work-item type runs
+// Second step of the picker for hybrid mode: pick which work-item type(s) run
 // in-place on the live checkout while everything else authors in isolated
-// worktrees. Renders a <select> + Back/Apply into the existing menu element.
+// worktrees. Renders a checkbox list (multi-select, W-mr2m1ute000a9c01) +
+// Back/Apply into the existing menu element. A checkbox list (rather than a
+// native <select multiple>) keeps the existing "click one row" affordance
+// discoverable while allowing more than one type to be selected at once.
 function _renderCheckoutModeHybridStep(menu, projectName) {
   const project = _findProjectInLastStatus(projectName);
   while (menu.firstChild) menu.removeChild(menu.firstChild);
@@ -235,21 +250,31 @@ function _renderCheckoutModeHybridStep(menu, projectName) {
 
   const label = document.createElement('div');
   label.className = 'checkout-mode-menu-item';
-  label.textContent = 'Work-item type to validate live:';
+  label.textContent = 'Work-item type(s) to validate live:';
   menu.appendChild(label);
 
-  const select = document.createElement('select');
-  select.className = 'checkout-mode-menu-select';
+  const currentTypes = _liveValidationTypesArray(project);
+  const preselect = currentTypes.length > 0 ? currentTypes : [CHECKOUT_MODE_HYBRID_DEFAULT_TYPE];
+
+  const checkboxList = document.createElement('div');
+  checkboxList.className = 'checkout-mode-menu-checkboxes';
+  const checkboxes = [];
   CHECKOUT_MODE_HYBRID_TYPES.forEach(function(t) {
-    const opt = document.createElement('option');
-    opt.value = t;
-    opt.textContent = t;
-    select.appendChild(opt);
+    const row = document.createElement('label');
+    row.className = 'checkout-mode-menu-checkbox-row';
+    const cb = document.createElement('input');
+    cb.type = 'checkbox';
+    cb.value = t;
+    cb.className = 'checkout-mode-menu-checkbox';
+    cb.checked = preselect.includes(t);
+    checkboxes.push(cb);
+    const text = document.createElement('span');
+    text.textContent = t;
+    row.appendChild(cb);
+    row.appendChild(text);
+    checkboxList.appendChild(row);
   });
-  select.value = (project && project.liveValidationType && CHECKOUT_MODE_HYBRID_TYPES.includes(project.liveValidationType))
-    ? project.liveValidationType
-    : CHECKOUT_MODE_HYBRID_DEFAULT_TYPE;
-  menu.appendChild(select);
+  menu.appendChild(checkboxList);
 
   const actions = document.createElement('div');
   actions.className = 'checkout-mode-menu-actions';
@@ -270,9 +295,10 @@ function _renderCheckoutModeHybridStep(menu, projectName) {
   applyBtn.className = 'checkout-mode-menu-btn checkout-mode-menu-btn-primary';
   applyBtn.textContent = 'Apply';
   applyBtn.addEventListener('click', function() {
-    const type = select.value;
+    const types = checkboxes.filter(function(cb) { return cb.checked; }).map(function(cb) { return cb.value; });
+    if (types.length === 0) return; // require at least one selected type
     _closeCheckoutModeMenu();
-    _applyCheckoutModeChange(projectName, 'live', type);
+    _applyCheckoutModeChange(projectName, 'live', types);
   });
   actions.appendChild(applyBtn);
 
@@ -284,12 +310,21 @@ function _renderCheckoutModeHybridStep(menu, projectName) {
 // call (mirrors projectChipRemove / removePinnedNote), then POSTs to
 // /api/settings. On failure, reverts the optimistic flip, re-renders, and
 // shows an error toast.
+//
+// `liveValidationType` accepts a single type string (legacy call sites) OR an
+// array of type strings (W-mr2m1ute000a9c01 — multi-select hybrid types);
+// whichever shape is passed through is what gets POSTed as
+// liveValidation.type, so shared.validateLiveValidation on the server decides
+// the final persisted shape.
 async function _applyCheckoutModeChange(projectName, newMode, liveValidationType) {
   const project = _findProjectInLastStatus(projectName);
   if (!project) return;
+  const typesForLabel = liveValidationType
+    ? (Array.isArray(liveValidationType) ? liveValidationType : [liveValidationType])
+    : [];
   const label = newMode === 'worktree'
     ? 'Worktrees'
-    : (liveValidationType ? ('Hybrid (' + liveValidationType + ')') : 'Live checkout');
+    : (typesForLabel.length > 0 ? ('Hybrid (' + typesForLabel.join(', ') + ')') : 'Live checkout');
   const ok = await confirmDialog({
     title: 'Change checkout mode?',
     message: 'Switch "' + projectName + '" to ' + label + '? This changes how every future dispatch on this project runs.',

package/dashboard/styles.css

@@ -1330,11 +1330,17 @@
     font-size: var(--text-xs); color: var(--muted); font-weight: 400;
     margin-top: 2px; line-height: 1.35;
   }
-  .checkout-mode-menu-select {
-    width: 100%; margin: 4px 0 8px; padding: 4px 6px;
-    background: var(--surface); color: var(--text); border: 1px solid var(--border);
-    border-radius: 4px;
+  .checkout-mode-menu-checkboxes {
+    display: flex; flex-direction: column; gap: 2px;
+    margin: 4px 0 8px; max-height: 220px; overflow-y: auto;
   }
+  .checkout-mode-menu-checkbox-row {
+    display: flex; align-items: center; gap: 6px;
+    padding: 4px 6px; border-radius: 4px; cursor: pointer;
+    color: var(--text); font-size: var(--text-sm);
+  }
+  .checkout-mode-menu-checkbox-row:hover { background: var(--surface); }
+  .checkout-mode-menu-checkbox { cursor: pointer; }
   .checkout-mode-menu-actions {
     display: flex; justify-content: flex-end; gap: 6px; padding-top: 4px;
   }

package/dashboard.js

@@ -4300,7 +4300,10 @@ function _resetPreambleCache() {
 function _projectCheckoutModeLabel(p) {
   const mode = shared.resolveCheckoutMode(p);
   if (mode === 'live' && p && p.liveValidation && p.liveValidation.type) {
-    return `hybrid (live-validation: ${p.liveValidation.type})`;
+    // liveValidation.type may be a single string (legacy) or an array of
+    // strings (W-mr2m1ute000a9c01 — multi-select hybrid types); render all.
+    const types = Array.isArray(p.liveValidation.type) ? p.liveValidation.type : [p.liveValidation.type];
+    return `hybrid (live-validation: ${types.join(', ')})`;
   }
   return mode;
 }

package/docs/README.md

@@ -61,6 +61,7 @@ Operational runbooks for engine operators and fleet maintainers.
 - [notes.md](notes.md) — Consolidated team knowledge: patterns, conventions, bugs, and build findings accumulated from agent inbox notes. Read by the engine and injected into agent prompts as shared context.
 - [auto-discovery.md](auto-discovery.md) — Auto-discovery and execution pipeline: the per-tick orchestration loop and the four work-discovery sources.
 - [diagnostics-memory.md](diagnostics-memory.md) — Operator runbook for the in-process memory + perf observability surface: `/api/diagnostics/memory[/history]`, `/api/diagnostics/heap-snapshot` guard-token capture, `MEMORY_BASELINE` log emissions, `--cpu-prof`/`--heap-prof` capture, and the `test/perf/soak.test.js` heap-growth regression gate.
+- [diagnostics-crash-reports.md](diagnostics-crash-reports.md) — Proactive Node crash-diagnostics reports (`--report-on-fatalerror --report-on-signal --diagnostic-dir=...`) for the engine.js process on Windows: where reports land, config/opt-out, and retention.
 - [engine-restart.md](engine-restart.md) — How agents survive an engine restart: state persistence, the 20-minute startup grace period, and orphan reattachment via PID files and `live-output.log`.
 - [human-vs-automated.md](human-vs-automated.md) — Quick reference table of which features humans start, run, decide, and recover, and the two human approval gates.
 - [kb-sweep.md](kb-sweep.md) — Knowledge-base sweep runbook: how `engine/kb-sweep.js` consolidates `notes/inbox/` into `knowledge/` and survives `minions restart`.

package/docs/diagnostics-crash-reports.md

@@ -0,0 +1,132 @@
+# Diagnostics: crash reports for the engine.js process (Windows)
+
+Operator runbook for the proactive crash-diagnostics feature shipped for
+`W-mr2c4i8m0004da94`. Follow-up from `W-mr2azk6i` (2026-07-01 engine.js
+crash-loop investigation): a run of 4 silent `engine.js` deaths left no
+exception/stack trace in `engine-stdio.log`, no Windows Event Viewer
+entries (Application/System logs were empty for the window), and no crash
+dumps in `C:\Windows\Minidump` or `%LOCALAPPDATA%\CrashDumps`. The box had
+no crash-event logging wired up at all, so a genuine native/access-violation
+crash of `node.exe` would have vanished without a trace.
+
+## What this does
+
+Every spawn of `engine.js` — via `minions start`/`restart` (`bin/minions.js`)
+**and** the supervisor's respawn-on-death path (`engine/supervisor.js`) —
+now gets Node's own diagnostic-report flags folded into `NODE_OPTIONS`:
+
+```
+--report-on-fatalerror --report-on-signal --diagnostic-dir=<MINIONS_HOME>/engine/diagnostics/crash-reports
+```
+
+This is a zero-dependency, built-in Node feature (no Sysinternals ProcDump
+or other external tool needed):
+
+- **`--report-on-fatalerror`** — writes a JSON diagnostic report the moment
+  the process hits an unrecoverable V8 error: out-of-memory, JS stack
+  overflow, or a native-addon crash. This is exactly the class of death a
+  silent `node.exe` disappearance on Windows would otherwise hide.
+- **`--report-on-signal`** — lets an operator request a report on demand by
+  sending the configured signal to the running engine PID: `SIGUSR2` on
+  POSIX, `SIGBREAK` on Windows (Node's default `--report-signal`). Useful to
+  capture a report while a hang is in progress, before deciding to kill it.
+- **`--diagnostic-dir=...`** — where both of the above land.
+
+Reports are plain JSON (`report.<timestamp>.<pid>.<seq>.json`) containing
+the JS/native stack, loaded modules, resource usage, and libuv handle
+summary at the moment of the event — see [Node's diagnostic report
+docs](https://nodejs.org/api/report.html) for the full schema.
+
+## Where reports land
+
+`<MINIONS_HOME>/engine/diagnostics/crash-reports/` — a sibling of the
+existing `engine/diagnostics/` directory used for heap snapshots and
+CPU/heap profiles (see [docs/diagnostics-memory.md](diagnostics-memory.md)
+§3–4), in its own subfolder so retention sweeps don't collide. The directory
+is gitignored and created on first spawn if missing
+(`getEngineCrashDiagnosticsEnv`, [`engine/shared.js`](../engine/shared.js)).
+
+## Config + opt-out
+
+```json
+{
+  "engine": {
+    "crashDiagnostics": {
+      "enabled": true,
+      "retainCount": 20
+    }
+  }
+}
+```
+
+- `enabled` (default `true`) — set `false` to disable the NODE_OPTIONS
+  injection entirely (falls back to the pre-existing no-diagnostics
+  behavior).
+- `retainCount` (default `20`) — how many `report.*.json` files are kept
+  before the oldest are pruned. Restart the engine (`minions restart`)
+  after editing `enabled`, since it only takes effect at the next spawn.
+
+Both live in `ENGINE_DEFAULTS.crashDiagnostics`
+([`engine/shared.js`](../engine/shared.js)).
+
+## Retention / cleanup
+
+Reports are pruned by `pruneCrashDiagnosticsReports` (`engine/shared.js`),
+called from `engine/cleanup.js#runCleanup` — the same periodic cleanup pass
+that already runs every `ENGINE_DEFAULTS.cleanupEvery` ticks (default 60
+ticks ≈ 10 min at the default 10 s tick interval). It keeps the newest
+`retainCount` files by mtime and deletes the rest, mirroring the existing
+heap-snapshot retention pattern in `dashboard.js#_heapSnapshotPrune`. Pruning
+is best-effort: a missing directory or a transient Windows file lock is
+swallowed and retried on the next cleanup pass.
+
+## Idempotency across the CLI → supervisor respawn chain
+
+Both `bin/minions.js` (initial spawn) and `engine/supervisor.js` (respawn on
+death) call the same `getEngineCrashDiagnosticsEnv(config)` helper. It checks
+whether the caller's `NODE_OPTIONS` already contains `--diagnostic-dir=`
+(which a spawned child inherits from its parent's env) and returns `{}`
+unchanged if so — so a CLI-spawned engine that later gets respawned by the
+supervisor never accumulates duplicate flags.
+
+## Inspecting a report after a crash
+
+```powershell
+Get-ChildItem "$env:USERPROFILE\.minions\engine\diagnostics\crash-reports" |
+  Sort-Object LastWriteTime -Descending | Select-Object -First 5
+
+Get-Content "$env:USERPROFILE\.minions\engine\diagnostics\crash-reports\report.<ts>.<pid>.001.json" |
+  ConvertFrom-Json | Select-Object javascriptStack, header
+```
+
+Key fields to check first: `header.event` (what triggered the report,
+e.g. `"FatalError"` or `"Signal"`), `javascriptStack`, `nativeStack`, and
+`resourceUsage` (memory/CPU at the moment of the event).
+
+## Requesting a report on demand (hang investigation)
+
+```powershell
+# Find the engine PID from engine/control.json, then:
+# Windows: send SIGBREAK-equivalent via node's report trigger utility, or
+# use Node's process.report.writeReport() interactively if you have a REPL
+# attached. The simplest cross-platform trigger is `process.kill(pid, 'SIGBREAK')`
+# from another Node process on Windows.
+node -e "process.kill(<pid>, 'SIGBREAK')"
+```
+
+A fresh `report.*.json` should appear in the crash-reports directory within
+a second or two, without killing the process.
+
+## Related modules and tests
+
+- Module: [`engine/shared.js`](../engine/shared.js) — `CRASH_REPORTS_DIR`,
+  `getEngineCrashDiagnosticsEnv`, `pruneCrashDiagnosticsReports`,
+  `ENGINE_DEFAULTS.crashDiagnostics`.
+- Spawn wiring: [`bin/minions.js`](../bin/minions.js)
+  (`spawnFullStackAndVerify`, the post-install/upgrade auto-start path) and
+  [`engine/supervisor.js`](../engine/supervisor.js) (`spawnEngine`).
+- Cleanup wiring: [`engine/cleanup.js`](../engine/cleanup.js) `runCleanup`.
+- Tests: [`test/unit/crash-diagnostics.test.js`](../test/unit/crash-diagnostics.test.js).
+- Related: [docs/diagnostics-memory.md](diagnostics-memory.md) (memory/GC/heap
+  observability — the sibling diagnostics surface this doc's directory lives
+  next to).

package/engine/cleanup.js

@@ -1633,6 +1633,19 @@ async function runCleanup(config, verbose = false) {
     cleaned.knowledgeScratch = reapKnowledgeScratch();
   } catch (e) { log('warn', `reapKnowledgeScratch: ${e.message}`); }
 
+  // 18. Prune old Node crash-diagnostics reports (W-mr2c4i8m0004da94). Node
+  // writes `report.*.json` to CRASH_REPORTS_DIR on a fatal V8 error or
+  // `--report-on-signal` request — see getEngineCrashDiagnosticsEnv. Keep
+  // only the newest config.engine.crashDiagnostics.retainCount (default 20)
+  // so a crash-loop or repeated on-demand reports don't accumulate unbounded.
+  cleaned.crashReports = 0;
+  try {
+    cleaned.crashReports = shared.pruneCrashDiagnosticsReports(config);
+    if (cleaned.crashReports > 0) {
+      log('info', `cleanup: pruned ${cleaned.crashReports} old crash-diagnostics report(s)`);
+    }
+  } catch (e) { log('warn', `pruneCrashDiagnosticsReports: ${e.message}`); }
+
   return cleaned;
 }
 

package/engine/lifecycle.js

@@ -6503,9 +6503,20 @@ function collapseAllDuplicatePrRecords(config) {
 
 // M003 — After a coding WI completes successfully, auto-dispatch a live-validation
 // WI when project.liveValidation.autoDispatch === true and the completed item is
-// a coding WI (not the validation type itself). Skips if the coding WI has no PR.
-// Deduplicates: a non-terminal WI with meta.liveValidationFor === codingWiId
-// blocks a second dispatch.
+// a coding WI (not one of the validation types itself). Skips if the coding WI
+// has no PR.
+//
+// liveValidation.type may be a single string (legacy / back-compat) or an
+// array of strings (W-mr2m1ute000a9c01 — multi-select hybrid types). When an
+// array, ONE validation WI is dispatched per configured type (each validation
+// WI still carries a single canonical `type` field so downstream routing —
+// playbooks, agent resolution, resolveCheckoutMode's membership check — keeps
+// working per-type).
+//
+// Deduplicates per (codingWiId, validationType) pair: a non-terminal WI with
+// meta.liveValidationFor === codingWiId AND meta.liveValidationType === type
+// blocks a second dispatch of that specific type, so multiple configured
+// types don't collide or skip each other.
 function autoDispatchLiveValidationWi(meta, config) {
   const item = meta?.item;
   if (!item?.id || !item?.type) return;
@@ -6521,8 +6532,12 @@ function autoDispatchLiveValidationWi(meta, config) {
   const lv = project.liveValidation;
   if (!lv || lv.autoDispatch !== true || !lv.type) return;
 
-  // Only auto-dispatch for coding WIs — skip if this IS the validation type.
-  if (item.type === lv.type) return;
+  const lvTypes = Array.isArray(lv.type) ? lv.type : [lv.type];
+
+  // Only auto-dispatch for coding WIs — skip types that ARE one of the
+  // configured validation types (avoid an infinite validate-the-validation loop).
+  const typesToDispatch = lvTypes.filter(t => t !== item.type);
+  if (typesToDispatch.length === 0) return;
 
   // Resolve PR reference: prefer the canonical stamped _pr field (set by
   // stampWiPrRef which runs earlier in runPostCompletionHooks), then fall
@@ -6538,34 +6553,41 @@ function autoDispatchLiveValidationWi(meta, config) {
     mutateWorkItems(wiPath, items => {
       if (!Array.isArray(items)) return items;
 
-      // Dedup: skip if a non-terminal WI already tracks this coding WI.
-      const existing = items.find(i =>
-        i &&
-        i.meta &&
-        i.meta.liveValidationFor === codingWiId &&
-        !PLAN_TERMINAL_STATUSES.has(i.status)
-      );
-      if (existing) {
-        log('info', `liveValidation: dedup — non-terminal validation WI ${existing.id} already exists for ${codingWiId}`);
-        return items;
-      }
+      for (const validationType of typesToDispatch) {
+        // Dedup: skip if a non-terminal WI already tracks this (coding WI, type)
+        // pair. Falls back to the WI's own `type` field when meta.liveValidationType
+        // is absent (back-compat with validation WIs created before this field
+        // existed, e.g. single-type configs from before W-mr2m1ute000a9c01).
+        const existing = items.find(i =>
+          i &&
+          i.meta &&
+          i.meta.liveValidationFor === codingWiId &&
+          (i.meta.liveValidationType === validationType ||
+            (!i.meta.liveValidationType && i.type === validationType)) &&
+          !PLAN_TERMINAL_STATUSES.has(i.status)
+        );
+        if (existing) {
+          log('info', `liveValidation: dedup — non-terminal validation WI ${existing.id} (type=${validationType}) already exists for ${codingWiId}`);
+          continue;
+        }
 
-      const validationWi = {
-        id: 'W-' + shared.uid(),
-        title: 'Validate: ' + (item.title || codingWiId),
-        type: lv.type,
-        status: WI_STATUS.PENDING,
-        depends_on: [codingWiId],
-        references: [prRef],
-        meta: { liveValidationFor: codingWiId },
-        project: projectName,
-        priority: item.priority || 'medium',
-        created: ts(),
-        createdBy: 'lifecycle:live-validation-auto-dispatch',
-      };
+        const validationWi = {
+          id: 'W-' + shared.uid(),
+          title: 'Validate: ' + (item.title || codingWiId),
+          type: validationType,
+          status: WI_STATUS.PENDING,
+          depends_on: [codingWiId],
+          references: [prRef],
+          meta: { liveValidationFor: codingWiId, liveValidationType: validationType },
+          project: projectName,
+          priority: item.priority || 'medium',
+          created: ts(),
+          createdBy: 'lifecycle:live-validation-auto-dispatch',
+        };
 
-      items.push(validationWi);
-      log('info', `liveValidation: auto-dispatched validation WI ${validationWi.id} (type=${lv.type}) for coding WI ${codingWiId}`);
+        items.push(validationWi);
+        log('info', `liveValidation: auto-dispatched validation WI ${validationWi.id} (type=${validationType}) for coding WI ${codingWiId}`);
+      }
       return items;
     });
   } catch (err) {

package/engine/shared.js

@@ -58,6 +58,13 @@ const MINIONS_DIR = process.env.MINIONS_TEST_DIR || resolveMinionsHome(false, {
   preferSourceCheckout: true,
 });
 const ENGINE_DIR = path.join(MINIONS_DIR, 'engine');
+// W-mr2c4i8m0004da94: Node's built-in `--diagnostic-dir` target for the
+// engine.js process's crash-diagnostics report (see
+// getEngineCrashDiagnosticsEnv / pruneCrashDiagnosticsReports below and
+// docs/diagnostics-crash-reports.md). Sibling of the existing
+// engine/diagnostics/ heap-snapshot dir, own subfolder so retention sweeps
+// don't collide with heap-snapshot pruning.
+const CRASH_REPORTS_DIR = path.join(ENGINE_DIR, 'diagnostics', 'crash-reports');
 const CONTROL_PATH = path.join(ENGINE_DIR, 'control.json');
 const COOLDOWNS_PATH = path.join(ENGINE_DIR, 'cooldowns.json');
 // W-mp60tw0u000j3931: Persistent cross-restart engine state (migration markers,
@@ -1633,6 +1640,69 @@ function openAppendLogFd(name, dir, opts) {
   }
 }
 
+// W-mr2c4i8m0004da94: proactive crash diagnostics for the engine.js node
+// process on Windows. Follow-up from W-mr2azk6i (2026-07-01 crash-loop
+// investigation): 4 silent engine.js deaths with no exception in
+// engine-stdio.log, no Windows Event Viewer entries, and no crash dumps —
+// this box had no crash-event logging wired up for a genuine native/AV
+// crash. Node's own diagnostic-report feature is a zero-dependency fix:
+// `--report-on-fatalerror` writes a JSON report on unrecoverable V8 errors
+// (OOM, stack overflow, native-addon segfault) and `--report-on-signal`
+// lets an operator request one on demand (SIGUSR2 on POSIX, SIGBREAK on
+// Windows) without installing anything (e.g. Sysinternals ProcDump).
+//
+// Callers: bin/minions.js (CLI `start`/`restart` spawn) and
+// engine/supervisor.js (respawn-on-death). Both spawn engine.js as a fresh
+// process before any config is loaded into memory, so this reads config.json
+// directly rather than expecting an already-parsed config object — pass the
+// parsed object in if the caller already has it (e.g. from its own
+// best-effort config.json read), or `null`/`undefined` to use the defaults.
+//
+// Idempotent: if the caller's NODE_OPTIONS already carries
+// `--diagnostic-dir=`, returns `{}` unchanged so the CLI's spawn -> a later
+// supervisor respawn -> another respawn chain never piles up duplicate
+// flags (child processes inherit NODE_OPTIONS from their parent env).
+function getEngineCrashDiagnosticsEnv(config, baseEnv) {
+  const env = baseEnv || process.env;
+  const cfg = (config && config.engine && config.engine.crashDiagnostics) || {};
+  const defaults = ENGINE_DEFAULTS.crashDiagnostics || {};
+  const enabled = cfg.enabled !== undefined ? cfg.enabled !== false : defaults.enabled !== false;
+  if (!enabled) return {};
+  const existing = String(env.NODE_OPTIONS || '');
+  if (existing.includes('--diagnostic-dir=')) return {};
+  try { fs.mkdirSync(CRASH_REPORTS_DIR, { recursive: true }); } catch { /* best effort — Node still tries to write on crash */ }
+  const flags = `--report-on-fatalerror --report-on-signal --diagnostic-dir=${CRASH_REPORTS_DIR}`;
+  return { NODE_OPTIONS: existing ? `${existing} ${flags}` : flags };
+}
+
+// Prune `report.*.json` files in CRASH_REPORTS_DIR down to the most-recent
+// `retainCount` (config.engine.crashDiagnostics.retainCount, default 20) by
+// mtime, mirroring dashboard.js's `_heapSnapshotPrune` retention pattern so
+// a leak-hunt session (or a genuine crash-loop) doesn't fill the disk with
+// reports unbounded. Best-effort: missing dir / unreadable stat / failed
+// unlink are swallowed. Called from engine/cleanup.js#runCleanup (fires
+// every ENGINE_DEFAULTS.cleanupEvery ticks, ~10 min at default tick
+// interval) so retention happens automatically without a dedicated sweep.
+function pruneCrashDiagnosticsReports(config) {
+  const cfg = (config && config.engine && config.engine.crashDiagnostics) || {};
+  const defaults = ENGINE_DEFAULTS.crashDiagnostics || {};
+  const retain = Number.isFinite(cfg.retainCount) ? cfg.retainCount : (defaults.retainCount || 20);
+  let names;
+  try { names = fs.readdirSync(CRASH_REPORTS_DIR); } catch { return 0; }
+  const candidates = names.filter(n => n.startsWith('report.') && n.endsWith('.json'));
+  if (candidates.length <= retain) return 0;
+  const stamped = candidates.map(n => {
+    try { return { n, mtime: fs.statSync(path.join(CRASH_REPORTS_DIR, n)).mtimeMs }; }
+    catch { return { n, mtime: 0 }; }
+  });
+  stamped.sort((a, b) => b.mtime - a.mtime); // newest first
+  let removed = 0;
+  for (const s of stamped.slice(retain)) {
+    try { fs.unlinkSync(path.join(CRASH_REPORTS_DIR, s.n)); removed++; } catch { /* best effort */ }
+  }
+  return removed;
+}
+
 function withFileLock(lockPath, fn, {
   timeoutMs = 5000,
   retryDelayMs = 25,
@@ -2783,8 +2853,14 @@ function resolveCheckoutMode(project, workItemType) {
   }
   if (canonical === CHECKOUT_MODES.LIVE) {
     // Apply liveValidation routing when the block is present and workItemType is provided.
+    // liveValidation.type may be a single string (legacy / back-compat) or an
+    // array of strings (W-mr2m1ute000a9c01, multi-select hybrid types) —
+    // normalize to an array and do a membership check so either shape works.
     if (project.liveValidation && workItemType !== undefined) {
-      return workItemType === project.liveValidation.type
+      const lvTypes = Array.isArray(project.liveValidation.type)
+        ? project.liveValidation.type
+        : [project.liveValidation.type];
+      return lvTypes.includes(workItemType)
         ? CHECKOUT_MODES.LIVE
         : CHECKOUT_MODES.WORKTREE;
     }
@@ -2840,13 +2916,26 @@ function validateCheckoutMode(value) {
 // Validate + normalize a per-project `liveValidation` block (hybrid mode).
 // Hybrid = checkoutMode:'live' + liveValidation:{ type, autoDispatch }: coding
 // work items author in isolated worktrees (escaping the live cap) while only
-// work items whose type === liveValidation.type run in-place on the live
+// work items whose type is IN liveValidation.type run in-place on the live
 // checkout. See resolveCheckoutMode (which routes per work-item type) and
 // docs/live-checkout-mode.md.
 //
+// `type` may be a single work-item-type string (legacy / back-compat) OR a
+// non-empty array of non-empty-string work-item types
+// (W-mr2m1ute000a9c01 — multi-select hybrid types, e.g. both "implement" and
+// "fix" validate live while other types stay in worktrees). Every reader of
+// liveValidation.type (resolveCheckoutMode, lifecycle.autoDispatchLiveValidationWi,
+// dashboard project mapper / pill / CC label) must handle BOTH shapes —
+// existing config.json entries with a plain string `type` continue to work
+// unchanged, no migration required.
+//
 // Returns:
 //   - undefined → caller should clear the field (empty / null / '' input)
-//   - { type, autoDispatch? } normalized object on success
+//   - { type, autoDispatch? } normalized object on success, where `type` is
+//     whatever shape the caller passed in (string stays a string; array stays
+//     a deduped array) — we intentionally do NOT force single-string input
+//     into an array so already-persisted single-type configs round-trip
+//     byte-identical through a Settings save that doesn't touch this field.
 // Throws HTTP 400 (via _httpError) on malformed input, or when the effective
 // checkout mode is not 'live' (liveValidation is meaningless without it — it is
 // silently ignored at resolve time, so we refuse to persist a misconfiguration).
@@ -2863,15 +2952,33 @@ function validateLiveValidation(value, opts) {
   if (checkoutMode !== CHECKOUT_MODES.LIVE) {
     throw _httpError(400, 'liveValidation requires checkoutMode "live" (hybrid mode). Set checkoutMode to "live" first, or clear liveValidation.');
   }
-  const type = typeof value.type === 'string' ? value.type.trim() : '';
-  if (!type) {
-    throw _httpError(400, 'Invalid liveValidation: "type" is required and must be a non-empty string — the work-item type that runs on the live checkout (e.g. "build-and-test").');
+  const typeErrorMsg = 'Invalid liveValidation: "type" is required and must be a non-empty string, or a non-empty array of non-empty-string work-item types — the work-item type(s) that run on the live checkout (e.g. "build-and-test" or ["implement", "fix"]).';
+  const rawType = value.type;
+  let out;
+  if (typeof rawType === 'string') {
+    const trimmed = rawType.trim();
+    if (!trimmed) throw _httpError(400, typeErrorMsg);
+    out = { type: trimmed };
+  } else if (Array.isArray(rawType)) {
+    if (!rawType.every(t => typeof t === 'string' && t.trim().length > 0)) {
+      throw _httpError(400, typeErrorMsg);
+    }
+    // Dedupe (preserving first-seen order) and cap at the number of distinct
+    // work-item types the engine recognizes — a longer array can only be
+    // full of duplicates or invented types.
+    const deduped = [...new Set(rawType.map(t => t.trim()))];
+    if (deduped.length === 0) throw _httpError(400, typeErrorMsg);
+    if (deduped.length > VALID_WORK_TYPES.size) {
+      throw _httpError(400, `Invalid liveValidation: "type" array has ${deduped.length} entries, more than the ${VALID_WORK_TYPES.size} distinct work-item types the engine recognizes — remove duplicates or invalid types.`);
+    }
+    out = { type: deduped };
+  } else {
+    throw _httpError(400, typeErrorMsg);
   }
-  const out = { type };
   // autoDispatch (optional): when true, lifecycle auto-creates a validation WI
-  // of `type` after each coding WI completes with a PR (engine/lifecycle.js
-  // autoDispatchLiveValidationWi). Coerce to a strict boolean; absent leaves it
-  // off so the operator opts in explicitly.
+  // per configured `type` after each coding WI completes with a PR
+  // (engine/lifecycle.js autoDispatchLiveValidationWi). Coerce to a strict
+  // boolean; absent leaves it off so the operator opts in explicitly.
   if (Object.prototype.hasOwnProperty.call(value, 'autoDispatch')) {
     out.autoDispatch = !!value.autoDispatch;
   }
@@ -3156,6 +3263,19 @@ const ENGINE_DEFAULTS = {
   // at the default 10s tickInterval. Set to 0 (or any non-positive integer)
   // to disable both the log emission and sidecar write cleanly (operator opt-out).
   memoryBaselineEveryTicks: 6,
+  // W-mr2c4i8m0004da94: proactive crash diagnostics for the engine.js
+  // node.exe process. When enabled (default), every spawn of engine.js
+  // (bin/minions.js `start`/`restart` AND engine/supervisor.js respawn-on-
+  // death) gets NODE_OPTIONS += `--report-on-fatalerror --report-on-signal
+  // --diagnostic-dir=<CRASH_REPORTS_DIR>` so a fatal V8 error (OOM, stack
+  // overflow, native-addon crash) or an operator-sent signal
+  // (SIGUSR2 POSIX / SIGBREAK Windows) leaves a JSON diagnostic report
+  // instead of a silent death. See getEngineCrashDiagnosticsEnv,
+  // pruneCrashDiagnosticsReports, and docs/diagnostics-crash-reports.md.
+  crashDiagnostics: {
+    enabled: true,
+    retainCount: 20, // report.*.json files kept in CRASH_REPORTS_DIR; oldest pruned during runCleanup (cleanupEvery ticks)
+  },
   stalledDispatchSweepEvery: 120,    // stalled-dispatch retry sweep (~20 min at default 10s tick) — only fires when all agents idle
   // W-mp5trwh60008386d: per-PR 404 must repeat across N consecutive successful base-repo probes
   // before flipping a PR to `abandoned`. A single 404 on `repos/{slug}/pulls/{n}` can be a transient
@@ -9091,6 +9211,9 @@ function createBackoffTracker({ baseMs = 30000, maxMs = 10 * 60 * 1000 } = {}) {
 module.exports = {
   MINIONS_DIR,
   ENGINE_DIR,
+  CRASH_REPORTS_DIR,
+  getEngineCrashDiagnosticsEnv,
+  pruneCrashDiagnosticsReports,
   resolveEngineCacheDir,
   openUrlInBrowser,
   CONTROL_PATH,

package/engine/supervisor.js

@@ -347,6 +347,18 @@ function _sqliteSpawnFlags() {
   return ['--experimental-sqlite'];
 }
 
+// W-mr2c4i8m0004da94: crash-diagnostics env additions for a supervisor-
+// initiated respawn. Best-effort config.json read — the supervisor spawns
+// engine.js before any config is loaded into memory, mirroring the same
+// read bin/minions.js does for its own engine spawns.
+function _engineCrashDiagnosticsEnv() {
+  const shared = _sharedOrNull();
+  if (!shared || typeof shared.getEngineCrashDiagnosticsEnv !== 'function') return {};
+  let cfg = null;
+  try { cfg = JSON.parse(fs.readFileSync(path.join(MINIONS_DIR, 'config.json'), 'utf8')); } catch { /* config may not exist */ }
+  try { return shared.getEngineCrashDiagnosticsEnv(cfg); } catch { return {}; }
+}
+
 function spawnEngine() {
   const out = openAppendFd('engine-stdio.log');
   const err = openAppendFd('engine-stdio.log');
@@ -355,6 +367,7 @@ function spawnEngine() {
     stdio: ['ignore', out, err],
     detached: true,
     windowsHide: true,
+    env: { ...process.env, ..._engineCrashDiagnosticsEnv() },
   });
   proc.unref();
   return proc.pid;

package/package.json

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

package/prompts/cc-system.md

@@ -325,7 +325,7 @@ Every configured project has an effective **checkout mode** — surfaced in your
 
 - **`worktree`** (default) — each dispatch gets its own isolated `git worktree`. Agents run fully in parallel; nothing touches the operator's working tree. Use for normal repos.
 - **`live`** — agents run **in-place** inside the project's `localPath` (no worktree). The engine caps this to **one mutating dispatch at a time** per project and **refuses on a dirty tree**. Use only when worktrees are unworkable (e.g. Android `repo`, submodules, deep Windows paths, emulators that bind the real checkout).
-- **`hybrid`** — `live` **plus** a `liveValidation: { type, autoDispatch }` block. Coding work items (`implement`/`fix`/`docs`/`decompose`) author in **isolated worktrees** (full parallelism), while **only** work items whose type matches `liveValidation.type` (e.g. `build-and-test`) run **in-place on the live checkout**. This is the best of both: parallel code authoring + a real on-disk build/validation that can't run in a worktree.
+- **`hybrid`** — `live` **plus** a `liveValidation: { type, autoDispatch }` block. Coding work items (`implement`/`fix`/`docs`/`decompose`) author in **isolated worktrees** (full parallelism), while **only** work items whose type matches `liveValidation.type` (e.g. `build-and-test`) run **in-place on the live checkout**. This is the best of both: parallel code authoring + a real on-disk build/validation that can't run in a worktree. `type` accepts a single string (e.g. `"build-and-test"`) or an array of strings (e.g. `["implement","fix"]`) to route multiple work-item types to the live checkout at once.
 
 **When to recommend hybrid:** the project's build/test/validation genuinely cannot run in an isolated worktree (it needs the real checkout — submodules, a `repo`-managed tree, an emulator/dev-server bound to `localPath`, deep-path tooling), **but** you still want coding agents to work in parallel rather than serialize through the single live checkout. If the *whole* workflow must run on the real tree, use plain `live`. If nothing needs the real tree, stay on `worktree`.