@yemi33/minions 0.1.2309 → 0.1.2310

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/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.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`.