@yemi33/minions 0.1.2309 → 0.1.2311

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,
@@ -158,7 +159,7 @@ const RENDER_VERSIONS = {
   schedules: 1,
   watches: 3,
   meetings: 1,
-  pipelines: 1,
+  pipelines: 2,
   pinned: 1,
   kbPayload: 2,
   // settings is a modal-driven section, not a tick-driven render — but the

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/js/render-pipelines.js

@@ -352,6 +352,11 @@ function renderPipelines(pipelines, opts) {
           '<span style="color:' + statusColor + ';font-size:var(--text-base);font-weight:600">' + escHtml(statusLabel) + '</span>' +
           (p.stopWhen ? '<span style="font-size:var(--text-xs);color:var(--yellow)" title="Auto-stops when condition met: ' + escHtml(typeof p.stopWhen === 'string' ? p.stopWhen : (p.stopWhen.check || 'condition')) + '">STOP-WHEN</span>' : '') +
           (p.enabled === false ? '<span style="font-size:var(--text-xs);color:var(--red)"' + (p._stopReason ? ' title="' + escHtml(p._stopReason) + '"' : '') + '>' + (p._stoppedBy ? 'AUTO-STOPPED' : 'DISABLED') + '</span>' : '') +
+          (p.enabled !== false
+            ? (activeRun
+                ? '<button class="pr-pager-btn" style="font-size:var(--text-xs);padding:2px 8px;color:var(--yellow);border-color:var(--yellow)" onclick="event.stopPropagation();_retriggerPipeline(\'' + escHtml(p.id) + '\',this)">Retrigger</button>'
+                : '<button class="btn-action btn-action-md" onclick="event.stopPropagation();_triggerPipeline(\'' + escHtml(p.id) + '\',this)">Run Now</button>')
+            : '') +
         '</div>' +
       '</div>' +
       resourcesHtml +
@@ -403,10 +408,12 @@ function openPipelineDetail(id) {
   html += '<div style="display:flex;justify-content:space-between;align-items:center">' +
     '<span style="font-size:var(--text-sm);color:var(--muted)">' + _renderPipelineTriggerLabel(p.trigger?.cron) + ' · ' + escHtml(_getPipelineStageLabel(p)) + '</span>' +
     '<div style="display:flex;gap:6px">' +
-      (activeRun
-        ? '<button class="btn-destructive btn-destructive-md" onclick="_abortPipeline(\'' + escHtml(id) + '\',this)">Abort</button>' +
-          '<button class="pr-pager-btn" style="font-size:var(--text-xs);padding:2px 8px;color:var(--yellow);border-color:var(--yellow)" onclick="_retriggerPipeline(\'' + escHtml(id) + '\',this)">Retrigger</button>'
-        : '<button class="btn-action btn-action-md" onclick="_triggerPipeline(\'' + escHtml(id) + '\',this)">Run Now</button>') +
+      (activeRun ? '<button class="btn-destructive btn-destructive-md" onclick="_abortPipeline(\'' + escHtml(id) + '\',this)">Abort</button>' : '') +
+      (p.enabled !== false
+        ? (activeRun
+            ? '<button class="pr-pager-btn" style="font-size:var(--text-xs);padding:2px 8px;color:var(--yellow);border-color:var(--yellow)" onclick="_retriggerPipeline(\'' + escHtml(id) + '\',this)">Retrigger</button>'
+            : '<button class="btn-action btn-action-md" onclick="_triggerPipeline(\'' + escHtml(id) + '\',this)">Run Now</button>')
+        : '') +
       '<button class="pr-pager-btn" style="font-size:var(--text-xs);padding:2px 8px;color:var(--blue);border-color:var(--blue)" onclick="openEditPipelineModal(\'' + escHtml(id) + '\')">Edit</button>' +
       '<button class="pr-pager-btn' + (_pipelineToggleInFlight.has(id) ? ' disabled' : '') + '" style="font-size:var(--text-xs);padding:2px 8px" onclick="_togglePipelineEnabled(\'' + escHtml(id) + '\',' + !p.enabled + ',this)">' + (p.enabled !== false ? 'Disable' : 'Enable') + '</button>' +
       '<button class="btn-destructive btn-destructive-md" onclick="_deletePipelineConfirm(\'' + escHtml(id) + '\')">Delete</button>' +

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/engine/ado.js

@@ -527,6 +527,35 @@ function votesToReviewStatus(votes) {
   return REVIEW_STATUS.PENDING;
 }
 
+/**
+ * Issue #633 — ADO never clears a reviewer's numeric vote when new commits
+ * land on a PR, so a hard-reject -10 vote stays live forever unless the
+ * reviewer explicitly re-votes. Without this check, `reviewStatus` gets
+ * permanently stuck at 'changes-requested' after a fix is pushed, and the
+ * auto re-review-after-fix flow (engine.js needsReReview, which only fires on
+ * reviewStatus === 'waiting') can never dispatch again for that PR.
+ *
+ * Treat a live -10 vote as stale/superseded — i.e. resolve to 'waiting'
+ * instead of 'changes-requested' — once a fix has completed after the vote
+ * was (most recently) cast AND no further push has landed since that fix:
+ *   - `pr.minionsReview.fixedAt` is set (a fix dispatch completed), and
+ *   - the fix happened after the last minions review that produced the
+ *     rejection (`!pr.lastReviewedAt || fixedAt > pr.lastReviewedAt` —
+ *     mirrors the `fixedAfterReview` gate in engine.js needsReReview), and
+ *   - no push has landed since that fix completed
+ *     (`!pr.lastPushedAt || pr.lastPushedAt <= fixedAt`).
+ * If a new push lands after the fix without a following fix completion, or
+ * the last review (and its -10) postdates the recorded fix, the reject is
+ * still live/fresh and reviewStatus correctly stays 'changes-requested'.
+ */
+function isStaleAdoRejectVote(pr) {
+  const fixedAt = pr?.minionsReview?.fixedAt;
+  if (!fixedAt) return false;
+  const fixedAfterReview = !pr.lastReviewedAt || fixedAt > pr.lastReviewedAt;
+  const noPushSinceFix = !pr.lastPushedAt || pr.lastPushedAt <= fixedAt;
+  return fixedAfterReview && noPushSinceFix;
+}
+
 // ─── Reviewer Vote Snapshots (W-mpg58wv3) ────────────────────────────────────
 //
 // ADO's reviewer API does NOT include the source commit at which a reviewer
@@ -1569,11 +1598,7 @@ async function pollPrStatus(config) {
       }
     } else if (votes.length > 0) {
       if (votes.some(v => v === -10)) {
-        if (pr.reviewStatus === REVIEW_STATUS.WAITING && pr.minionsReview?.fixedAt && (!pr.lastPushedAt || pr.lastPushedAt <= pr.minionsReview.fixedAt)) {
-          newReviewStatus = REVIEW_STATUS.WAITING;
-        } else {
-          newReviewStatus = REVIEW_STATUS.CHANGES_REQUESTED;
-        }
+        newReviewStatus = isStaleAdoRejectVote(pr) ? REVIEW_STATUS.WAITING : REVIEW_STATUS.CHANGES_REQUESTED;
       }
       else if (votes.some(v => v >= 5)) newReviewStatus = REVIEW_STATUS.APPROVED;
       else if (votes.some(v => v === -5)) newReviewStatus = REVIEW_STATUS.WAITING;
@@ -2346,7 +2371,16 @@ async function checkLiveReviewStatus(pr, project) {
     if (!prData) return null;
     const votes = (prData.reviewers || []).map(r => r.vote).filter(v => v !== undefined);
     if (votes.length === 0) return 'pending';
-    return votesToReviewStatus(votes);
+    const liveStatus = votesToReviewStatus(votes);
+    // Issue #633: the live vote check is the pre-dispatch gate for
+    // engine.js needsReReview — it must apply the same stale-reject-vote
+    // override as pollPrStatus, or a cached 'waiting' status set below by
+    // the poller gets immediately reverted back to 'changes-requested' here
+    // before a re-review can ever be dispatched.
+    if (liveStatus === REVIEW_STATUS.CHANGES_REQUESTED && isStaleAdoRejectVote(pr)) {
+      return REVIEW_STATUS.WAITING;
+    }
+    return liveStatus;
   } catch (e) {
     log('warn', `Live review check for ${pr.id}: ${e.message}`);
     return null;

package/engine/github.js

@@ -705,6 +705,24 @@ async function forEachActiveGhPr(config, callback) {
   return totalUpdated;
 }
 
+/**
+ * Issue #633 (mirror of engine/ado.js isStaleAdoRejectVote) — GitHub reviews
+ * generally get dismissed/replaced when a reviewer re-reviews, but a stale
+ * CHANGES_REQUESTED review from a login that never re-reviews after a fix can
+ * still pin `reviewStatus` at 'changes-requested' forever (the reviewer's
+ * review state persists until dismissed). Mirror the ADO fix so the same
+ * fixedAfterReview + no-push-since-fix override applies here: treat a live
+ * CHANGES_REQUESTED review as stale/superseded once a fix has completed after
+ * the review that produced it and no further push has landed since that fix.
+ */
+function isStaleGithubChangesRequested(pr) {
+  const fixedAt = pr?.minionsReview?.fixedAt;
+  if (!fixedAt) return false;
+  const fixedAfterReview = !pr.lastReviewedAt || fixedAt > pr.lastReviewedAt;
+  const noPushSinceFix = !pr.lastPushedAt || pr.lastPushedAt <= fixedAt;
+  return fixedAfterReview && noPushSinceFix;
+}
+
 // ─── PR Status Polling ──────────────────────────────────────────────────────
 
 async function pollPrStatus(config) {
@@ -999,11 +1017,7 @@ async function pollPrStatus(config) {
       if (pr.reviewStatus === REVIEW_STATUS.APPROVED) {
         newReviewStatus = REVIEW_STATUS.APPROVED;
       } else if (states.some(s => s === 'CHANGES_REQUESTED')) {
-        if (pr.reviewStatus === REVIEW_STATUS.WAITING && pr.minionsReview?.fixedAt && (!pr.lastPushedAt || pr.lastPushedAt <= pr.minionsReview.fixedAt)) {
-          newReviewStatus = REVIEW_STATUS.WAITING;
-        } else {
-          newReviewStatus = REVIEW_STATUS.CHANGES_REQUESTED;
-        }
+        newReviewStatus = isStaleGithubChangesRequested(pr) ? REVIEW_STATUS.WAITING : REVIEW_STATUS.CHANGES_REQUESTED;
       }
       else if (states.some(s => s === 'APPROVED')) newReviewStatus = REVIEW_STATUS.APPROVED;
       else if (states.length > 0) newReviewStatus = REVIEW_STATUS.PENDING;
@@ -1575,7 +1589,13 @@ async function checkLiveReviewStatus(pr, project) {
       latestByUser.set(r.user?.login || '', r.state);
     }
     const states = [...latestByUser.values()];
-    if (states.some(s => s === 'CHANGES_REQUESTED')) return REVIEW_STATUS.CHANGES_REQUESTED;
+    // Issue #633: mirror the pollPrStatus stale-reject override here — this
+    // live check is the pre-dispatch gate for engine.js needsReReview, and
+    // without the override it immediately reverts a cached 'waiting' status
+    // back to 'changes-requested' before a re-review can ever be dispatched.
+    if (states.some(s => s === 'CHANGES_REQUESTED')) {
+      return isStaleGithubChangesRequested(pr) ? REVIEW_STATUS.WAITING : REVIEW_STATUS.CHANGES_REQUESTED;
+    }
     if (states.some(s => s === 'APPROVED')) return REVIEW_STATUS.APPROVED;
     if (states.length > 0) return REVIEW_STATUS.PENDING;
     return REVIEW_STATUS.PENDING;

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

@@ -2853,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;
     }
@@ -2910,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).
@@ -2933,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;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.2309",
+  "version": "0.1.2311",
   "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`.