@yemi33/minions 0.1.2380 → 0.1.2381

package/dashboard/js/refresh.js

@@ -138,7 +138,7 @@ const RENDER_VERSIONS = {
   // Bumped 4→5 for the clickable checkout-mode pill + picker (W-mr1b67zi0006b788).
   // Bumped 5→6 for multi-select hybrid liveValidation.type support (W-mr2m1ute000a9c01).
   // Bumped 6→7 for the liveValidation.autoDispatch toggle + pill "· auto-validate" suffix (W-mr2q361a00097e5c).
-  projects: 7,
+  projects: 9,
   notes: 1,
   prd: 3,
   prs: 3,

package/dashboard/js/render-other.js

@@ -105,13 +105,13 @@ function _renderProjectBranch(p) {
 // "Live checkout" (live — agents run in-place inside the operator's working
 // tree). Driven by p.checkoutMode (shared.CHECKOUT_MODES; engine defaults
 // unset → 'worktree'). Live is the riskier/special mode (capped to one mutating
-// dispatch per project, refuses on a dirty tree) so it gets a more prominent
-// color than the muted worktree pill.
+// dispatch per project, with configurable dirty-tree recovery) so it gets a
+// more prominent color than the muted worktree pill.
 //
 // Hybrid live-validation: when checkoutMode is 'live' AND p.liveValidationType
-// is set, coding WIs author in isolated worktrees and only the named validation
-// type runs in-place on the live checkout. This is a materially different
-// dispatch profile from full-live, so it gets its own pill.
+// is set, only selected WI types run in-place and all others use isolated
+// worktrees. This is a materially different dispatch profile from full-live,
+// so it gets its own pill.
 // W-mr1b67zi0006b788: the pill is clickable — opens an inline picker (see
 // _openCheckoutModeMenu below) to switch between Worktrees / Live checkout /
 // Hybrid dispatch modes without leaving the Projects view. Shared
@@ -125,6 +125,10 @@ function _renderWorktreeModePill(p) {
   const common = ' data-checkout-pill="' + name + '" role="button" tabindex="0" aria-haspopup="true" aria-label="Change checkout mode"';
   if (p.checkoutMode === 'live') {
     const types = _liveValidationTypesArray(p);
+    if (p.liveValidationInvalid) {
+      const effectiveTypes = types.length > 0 ? types.join(', ') : 'none';
+      return ' <span class="project-mode-pill project-mode-hybrid project-mode-pill-clickable project-warn"' + common + ' title="Invalid hybrid configuration — unsupported settings are ignored. Effective live work-item types: ' + escHtml(effectiveTypes) + '. Click to repair.">⚠ Hybrid · invalid</span>';
+    }
     if (types.length > 0) {
       const typesText = types.join(', ');
       const vt = escapeHtml(typesText);
@@ -134,20 +138,19 @@ function _renderWorktreeModePill(p) {
       const autoDispatch = p.liveValidationAutoDispatch === true;
       const autoSuffix = autoDispatch ? ' · auto-validate' : '';
       const autoTitleBit = autoDispatch
-        ? ' A validation work item is automatically dispatched after each coding work item completes.'
-        : ' Auto-validation is OFF — validation must be dispatched manually after each coding work item completes.';
-      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).' + escHtml(autoTitleBit) + ' Click to change.">⚡ Hybrid · ' + vt + escHtml(autoSuffix) + '</span>';
+        ? ' A test work item is automatically dispatched after each eligible coding work item completes.'
+        : ' Auto-validation is OFF — validation must be dispatched manually.';
+      return ' <span class="project-mode-pill project-mode-hybrid project-mode-pill-clickable"' + common + ' title="Hybrid dispatch — only the &quot;' + vt + '&quot; work-item type(s) run in-place; all others use isolated worktrees. Live work is capped to one mutating dispatch, and dirty-tree handling follows the configured auto-stash/reset policy.' + escHtml(autoTitleBit) + ' Click to change.">⚡ Hybrid · ' + vt + escHtml(autoSuffix) + '</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>';
+    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. Dirty-tree handling follows the configured auto-stash/reset policy. Click to change.">⚡ Live checkout</span>';
   }
   return ' <span class="project-mode-pill project-mode-isolated project-mode-pill-clickable"' + common + ' title="Worktree dispatch mode (default) — each agent runs in its own git worktree. Click to change.">Worktrees</span>';
 }
 
-// Work-item types eligible for hybrid live-validation (W-mr1b67zi0006b788).
-// Mirrors the set the server documents for project.liveValidation.type;
-// intentionally excludes the illustrative "build-and-test" example from the
-// server comments since that isn't a real WORK_TYPE value.
-const CHECKOUT_MODE_HYBRID_TYPES = ['implement', 'fix', 'docs', 'decompose', 'explore', 'ask', 'review', 'test', 'verify', 'setup'];
+// Canonical work-item types that can meaningfully use the live checkout.
+// Read-only root tasks are omitted because hybrid routing cannot change where
+// they run. `build-and-test` is a playbook alias; `test` is the WI type.
+const CHECKOUT_MODE_HYBRID_TYPES = ['test', 'implement', 'implement:large', 'fix', 'build-fix-complex', 'docs', 'decompose', 'review', 'verify', 'setup'];
 const CHECKOUT_MODE_HYBRID_DEFAULT_TYPE = 'test';
 
 function _findProjectInLastStatus(name) {
@@ -230,9 +233,10 @@ function _openCheckoutModeMenu(projectName, anchorEl) {
       desc.textContent = descText;
       item.appendChild(desc);
     }
+    const liveTypes = _liveValidationTypesArray(project);
     const isActive = (mode === 'worktree' && project.checkoutMode !== 'live')
-      || (mode === 'live' && project.checkoutMode === 'live' && _liveValidationTypesArray(project).length === 0)
-      || (mode === 'hybrid' && project.checkoutMode === 'live' && _liveValidationTypesArray(project).length > 0);
+      || (mode === 'live' && project.checkoutMode === 'live' && liveTypes.length === 0 && !project.liveValidationInvalid)
+      || (mode === 'hybrid' && project.checkoutMode === 'live' && (liveTypes.length > 0 || project.liveValidationInvalid));
     if (isActive) {
       item.setAttribute('aria-checked', 'true');
       item.classList.add('checkout-mode-menu-item-active');
@@ -254,8 +258,8 @@ function _openCheckoutModeMenu(projectName, anchorEl) {
   }
 
   addItem('Worktrees (default)', 'worktree', 'Each dispatch runs in its own isolated git worktree. Fully parallel, never touches your working directory.');
-  addItem('Live checkout', 'live', 'Agents run in-place in the project folder. One mutating dispatch at a time; refuses to run on a dirty tree.');
-  addItem('Hybrid dispatch…', 'hybrid', 'Coding work authors in isolated worktrees; only a chosen validation step (e.g. build-and-test) runs on the real checkout.');
+  addItem('Live checkout', 'live', 'Agents run in-place in the project folder. One mutating dispatch at a time; dirty-tree handling follows the auto-stash/reset policy.');
+  addItem('Hybrid dispatch…', 'hybrid', 'Only chosen work-item types (normally test) use the real checkout; all others use isolated worktrees.');
 
   document.body.appendChild(menu);
   const rect = anchorEl.getBoundingClientRect();
@@ -286,7 +290,7 @@ function _renderCheckoutModeHybridStep(menu, projectName) {
 
   const label = document.createElement('div');
   label.className = 'checkout-mode-menu-item';
-  label.textContent = 'Work-item type(s) to validate live:';
+  label.textContent = 'Work-item type(s) to run live:';
   menu.appendChild(label);
 
   const currentTypes = _liveValidationTypesArray(project);
@@ -325,10 +329,23 @@ function _renderCheckoutModeHybridStep(menu, projectName) {
   autoDispatchCb.className = 'checkout-mode-menu-checkbox checkout-mode-menu-autodispatch-checkbox';
   autoDispatchCb.checked = project.liveValidationAutoDispatch === true;
   const autoDispatchText = document.createElement('span');
-  autoDispatchText.textContent = 'Automatically validate after each coding work item completes';
+  autoDispatchText.textContent = 'Automatically run a test validation after each eligible coding work item completes';
   autoDispatchRow.appendChild(autoDispatchCb);
   autoDispatchRow.appendChild(autoDispatchText);
   menu.appendChild(autoDispatchRow);
+  const testTypeCheckbox = checkboxes.find(function(cb) {
+    return cb.value === CHECKOUT_MODE_HYBRID_DEFAULT_TYPE;
+  });
+  function syncAutoDispatchType() {
+    if (autoDispatchCb.checked && testTypeCheckbox) testTypeCheckbox.checked = true;
+  }
+  autoDispatchCb.addEventListener('change', syncAutoDispatchType);
+  if (testTypeCheckbox) {
+    testTypeCheckbox.addEventListener('change', function() {
+      if (!testTypeCheckbox.checked) autoDispatchCb.checked = false;
+    });
+  }
+  syncAutoDispatchType();
 
   const actions = document.createElement('div');
   actions.className = 'checkout-mode-menu-actions';
@@ -349,9 +366,9 @@ function _renderCheckoutModeHybridStep(menu, projectName) {
   applyBtn.className = 'checkout-mode-menu-btn checkout-mode-menu-btn-primary';
   applyBtn.textContent = 'Apply';
   applyBtn.addEventListener('click', function() {
+    const autoDispatch = autoDispatchCb.checked;
     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
-    const autoDispatch = autoDispatchCb.checked;
     _closeCheckoutModeMenu();
     _applyCheckoutModeChange(projectName, 'live', types, autoDispatch);
   });
@@ -392,8 +409,8 @@ async function _applyCheckoutModeChange(projectName, newMode, liveValidationType
   // explicitly in the confirm message rather than burying it in the label.
   const autoDispatchNote = typesForLabel.length > 0
     ? (autoDispatchOn
-      ? ' Auto-validation will be turned ON — a validation work item will be dispatched automatically after each coding work item completes, and coding agents will skip local builds/tests.'
-      : ' Auto-validation will be OFF — you will need to dispatch validation manually after each coding work item completes.')
+      ? ' Auto-validation will be turned ON — a test work item will be dispatched automatically after each eligible coding work item completes, and eligible coding agents will skip local builds/tests.'
+      : ' Auto-validation will be OFF — you will need to dispatch validation manually.')
     : '';
   const ok = await confirmDialog({
     title: 'Change checkout mode?',
@@ -407,12 +424,14 @@ async function _applyCheckoutModeChange(projectName, newMode, liveValidationType
   const prevMode = project.checkoutMode;
   const prevType = project.liveValidationType;
   const prevAutoDispatch = project.liveValidationAutoDispatch;
+  const prevInvalid = project.liveValidationInvalid;
   const nextType = (newMode === 'live' && liveValidationType) ? liveValidationType : null;
   // Optimistic flip BEFORE awaiting the API call (per dashboard convention —
   // see projectChipRemove / removePinnedNote); reverted in the catch below.
   project.checkoutMode = newMode;
   project.liveValidationType = nextType;
   project.liveValidationAutoDispatch = nextType ? autoDispatchOn : false;
+  project.liveValidationInvalid = false;
   if (window._lastStatus && Array.isArray(window._lastStatus.projects)) renderProjects(window._lastStatus.projects);
 
   try {
@@ -434,6 +453,7 @@ async function _applyCheckoutModeChange(projectName, newMode, liveValidationType
     project.checkoutMode = prevMode;
     project.liveValidationType = prevType;
     project.liveValidationAutoDispatch = prevAutoDispatch;
+    project.liveValidationInvalid = prevInvalid;
     if (window._lastStatus && Array.isArray(window._lastStatus.projects)) renderProjects(window._lastStatus.projects);
     showToast('cmd-toast', 'Failed to update checkout mode: ' + (err && err.message || err), false);
   }

package/dashboard/js/settings.js

@@ -277,16 +277,18 @@ async function openSettings() {
     // (honors the legacy worktreeMode field). Chip is hidden by default and
     // toggled reactively below.
     // W-mr9mx93d000x1dda — third option "Hybrid dispatch": checkoutMode:'live'
-    // PLUS a liveValidation block (coding WIs author in isolated worktrees; only
-    // the chosen validation type(s) run in-place on the live checkout, with an
-    // optional auto-dispatch-after-coding toggle). This mirrors the Projects-bar
+    // PLUS a liveValidation block (only chosen work-item types run in-place;
+    // all others use isolated worktrees, with an optional test auto-dispatch
+    // after eligible coding work). This mirrors the Projects-bar
     // picker (render-other.js _openCheckoutModeMenu / _renderCheckoutModeHybridStep)
     // so both surfaces configure the SAME liveValidation shape identically.
     var currentWtMode = (p.checkoutMode === 'live') ? 'live' : 'worktree';
     var lvTypes = (window._liveValidationTypesArray ? window._liveValidationTypesArray(p) : []);
-    // 3-way UI mode: worktree / live / hybrid. Hybrid = live + >=1 validation type.
+    // 3-way UI mode: worktree / live / hybrid. Keep invalid persisted hybrid
+    // blocks in the hybrid editor so saving can repair rather than hide them as
+    // full-live.
     var currentCheckoutMode = (currentWtMode === 'live')
-      ? (lvTypes.length > 0 ? 'hybrid' : 'live')
+      ? ((lvTypes.length > 0 || p.liveValidationInvalid) ? 'hybrid' : 'live')
       : 'worktree';
     var hybridTypes = window.CHECKOUT_MODE_HYBRID_TYPES || [];
     var hybridDefaultType = window.CHECKOUT_MODE_HYBRID_DEFAULT_TYPE || 'test';
@@ -303,26 +305,26 @@ async function openSettings() {
     var hybridPanel =
       '<div data-checkout-hybrid-panel="' + escHtml(p.name) + '" style="' + (currentCheckoutMode === 'hybrid' ? '' : 'display:none;') + 'margin-top:6px">' +
         '<div style="padding:6px 8px;background:rgba(234,179,8,0.12);border:1px solid var(--yellow);border-radius:4px;color:var(--yellow);font-size:var(--text-xs);line-height:1.4;margin-bottom:6px">' +
-          '⚠ Hybrid mode: coding work items author in isolated worktrees; only the chosen validation type(s) run in-place on the live checkout (one mutating dispatch at a time; refused on a dirty tree).' +
+          '⚠ Hybrid mode: only the chosen work-item type(s) run in-place on the live checkout; all others use isolated worktrees (one mutating dispatch at a time; dirty-tree recovery follows the live-checkout auto-stash/reset settings).' +
         '</div>' +
-        '<div style="font-size:var(--text-sm);color:var(--muted);margin-bottom:2px">Work-item type(s) to validate live:</div>' +
+        '<div style="font-size:var(--text-sm);color:var(--muted);margin-bottom:2px">Work-item type(s) to run live:</div>' +
         '<div style="margin-bottom:4px">' + hybridTypeChecks + '</div>' +
         '<label style="display:inline-flex;align-items:center;gap:6px;font-size:var(--text-sm);color:var(--text);margin-top:2px">' +
           '<input type="checkbox" id="set-liveValidationAutoDispatch-' + escHtml(p.name) + '"' + (hybridAutoPre ? ' checked' : '') + '>' +
-          '<span>Automatically validate after each coding work item completes</span>' +
+          '<span>Automatically run a test validation after each eligible coding work item completes</span>' +
         '</label>' +
-        '<div data-checkout-hybrid-error="' + escHtml(p.name) + '" style="display:none;margin-top:6px;color:var(--red);font-size:var(--text-xs)">Select at least one work-item type to validate live.</div>' +
+        '<div data-checkout-hybrid-error="' + escHtml(p.name) + '" style="display:none;margin-top:6px;color:var(--red);font-size:var(--text-xs)">Select at least one work-item type to run live.</div>' +
       '</div>';
     var worktreeModeBlock =
       '<div data-search="' + escHtml(wtModeSearch) + '" style="margin-bottom:6px">' +
         '<label style="font-size:var(--text-sm);color:var(--muted);display:block;margin-bottom:2px">Checkout mode</label>' +
         '<select id="set-checkoutMode-' + escHtml(p.name) + '" data-checkout-mode-select="' + escHtml(p.name) + '" style="width:100%;padding:4px 6px;background:var(--surface);border:1px solid var(--border);border-radius:4px;color:var(--text);font-size:var(--text-md)">' +
           '<option value="worktree" title="Each dispatch runs in its own isolated git worktree. Fully parallel, never touches your working directory."' + (currentCheckoutMode === 'worktree' ? ' selected' : '') + '>Worktree (default)</option>' +
-          '<option value="live" title="Agents run in-place in the project folder. One mutating dispatch at a time; refuses to run on a dirty tree."' + (currentCheckoutMode === 'live' ? ' selected' : '') + '>Live checkout</option>' +
-          '<option value="hybrid" title="Coding work authors in isolated worktrees; only a chosen validation step runs on the real checkout."' + (currentCheckoutMode === 'hybrid' ? ' selected' : '') + '>Hybrid dispatch</option>' +
+          '<option value="live" title="Agents run in-place in the project folder. One mutating dispatch at a time; dirty-tree handling follows the auto-stash/reset policy."' + (currentCheckoutMode === 'live' ? ' selected' : '') + '>Live checkout</option>' +
+          '<option value="hybrid" title="Only chosen work-item types run on the real checkout; all others use isolated worktrees."' + (currentCheckoutMode === 'hybrid' ? ' selected' : '') + '>Hybrid dispatch</option>' +
         '</select>' +
         '<div data-checkout-mode-chip="' + escHtml(p.name) + '" style="' + (currentCheckoutMode === 'live' ? '' : 'display:none;') + 'margin-top:6px;padding:6px 8px;background:rgba(234,179,8,0.12);border:1px solid var(--yellow);border-radius:4px;color:var(--yellow);font-size:var(--text-xs);line-height:1.4">' +
-          '⚠ Live mode: dispatches run directly in this repo\'s checkout. Only one mutating dispatch runs at a time. Dirty working trees block dispatch — commit or stash before running.' +
+          '⚠ Live mode: dispatches run directly in this repo\'s checkout. Only one mutating dispatch runs at a time. Dirty-tree behavior follows the auto-stash/reset settings below.' +
         '</div>' +
         hybridPanel +
       '</div>';
@@ -774,6 +776,17 @@ async function openSettings() {
       if (hybridPanel) hybridPanel.style.display = (sel.value === 'hybrid') ? '' : 'none';
     });
   });
+  document.querySelectorAll('[id^="set-liveValidationAutoDispatch-"]').forEach(function(autoDispatch) {
+    autoDispatch.addEventListener('change', function() {
+      if (!autoDispatch.checked) return;
+      const projectName = autoDispatch.id.slice('set-liveValidationAutoDispatch-'.length);
+      const esc = (window.CSS && CSS.escape ? CSS.escape(projectName) : projectName);
+      const testType = document.querySelector(
+        '[data-live-validation-type="' + esc + '"][value="test"]',
+      );
+      if (testType) testType.checked = true;
+    });
+  });
 }
 
 // Lazily open/close the per-agent charter editor in the Settings Agents table.
@@ -1244,13 +1257,23 @@ async function saveSettings() {
         const types = [];
         typeEls.forEach(function(el) { if (el && el.checked) types.push(el.value); });
         const errEl = document.querySelector('[data-checkout-hybrid-error="' + esc + '"]');
+        const autoEl = document.getElementById('set-liveValidationAutoDispatch-' + p.name);
+        const autoDispatch = autoEl?.checked === true;
         if (types.length === 0) {
-          hybridValidationErrors.push(p.name);
-          if (errEl) errEl.style.display = '';
+          hybridValidationErrors.push(p.name + ': select at least one live type');
+          if (errEl) {
+            errEl.textContent = 'Select at least one work-item type to run live.';
+            errEl.style.display = '';
+          }
+        } else if (autoDispatch && types.indexOf('test') === -1) {
+          hybridValidationErrors.push(p.name + ': auto-validation requires test');
+          if (errEl) {
+            errEl.textContent = 'Automatic validation requires the test type.';
+            errEl.style.display = '';
+          }
         } else {
           if (errEl) errEl.style.display = 'none';
-          const autoEl = document.getElementById('set-liveValidationAutoDispatch-' + p.name);
-          liveValidation = { type: types, autoDispatch: !!(autoEl && autoEl.checked) };
+          liveValidation = { type: types, autoDispatch };
         }
       }
       // W-mqtvnnj1000357fa — per-project live-checkout auto-stash override.
@@ -1280,7 +1303,7 @@ async function saveSettings() {
     });
 
     if (hybridValidationErrors.length > 0) {
-      throw new Error('Hybrid dispatch needs at least one validation work-item type for: ' + hybridValidationErrors.join(', '));
+      throw new Error('Invalid hybrid dispatch configuration: ' + hybridValidationErrors.join(', '));
     }
 
     // Save config

package/dashboard.js

@@ -421,8 +421,14 @@ function mergeSettingsConfigUpdate(current, candidate, body, patch = {}) {
       // `candidate` in handleSettingsUpdate) is silently dropped on the way
       // through mergeSettingsConfigUpdate → mutateDashboardConfig and never
       // reaches disk — the endpoint would return 200 but persist nothing.
+      const modeWasRequested = Object.prototype.hasOwnProperty.call(update, 'checkoutMode')
+        || Object.prototype.hasOwnProperty.call(update, 'worktreeMode');
       if (Object.prototype.hasOwnProperty.call(candidateProject, 'checkoutMode')) {
         currentProject.checkoutMode = candidateProject.checkoutMode;
+      } else if (Object.prototype.hasOwnProperty.call(candidateProject, 'worktreeMode')) {
+        currentProject.checkoutMode = shared.resolveCheckoutMode(candidateProject);
+      } else if (!modeWasRequested && Object.prototype.hasOwnProperty.call(currentProject, 'worktreeMode')) {
+        currentProject.checkoutMode = shared.resolveCheckoutMode(currentProject);
       } else {
         delete currentProject.checkoutMode;
       }
@@ -832,7 +838,7 @@ async function copyWorkItemPrFields(item, input, pr = null, opts = {}) {
     if (structuredRef) {
       prRef = structuredRef; // explicit operator intent — trusted, no verification
     } else {
-      if (String(item?.type || '').toLowerCase() !== WORK_TYPE.FIX) return;
+      if (!shared.isFixLikeWorkType(String(item?.type || '').toLowerCase())) return;
       const looseRef = getWorkItemPrRef(input);
       if (!looseRef) return;
       // issue #246 — confirm the loose ref is a PR (not an issue) before stamping.
@@ -2538,26 +2544,7 @@ function _buildStatusSlowState() {
         ...status,
         mainBranch,
         branchMismatch,
-        // P-a3f9b209 / W-mqgzcrln002613b3 — surface the per-project dispatch
-        // mode so the Projects view can render a "Worktrees" vs "Live checkout"
-        // pill. resolveCheckoutMode honors the legacy worktreeMode field and
-        // defaults to 'worktree' when unset (matches engine spawn behavior).
-        checkoutMode: shared.resolveCheckoutMode(p),
-        // Surface the hybrid live-validation type (when configured) so the
-        // Projects view can render a distinct "Hybrid" pill: coding WIs author
-        // in isolated worktrees while only the named validation type runs
-        // in-place on the live checkout. Only meaningful when checkoutMode is
-        // 'live'; null otherwise (full-live or worktree projects).
-        liveValidationType: (shared.resolveCheckoutMode(p) === 'live' && p.liveValidation && p.liveValidation.type)
-          ? p.liveValidation.type
-          : null,
-        // W-mr2q361a00097e5c — surface liveValidation.autoDispatch alongside
-        // .type so the hybrid picker can preselect the "auto-validate"
-        // checkbox and the pill can visibly distinguish manual vs
-        // auto-validating hybrid projects. Only meaningful when checkoutMode
-        // is 'live'; false otherwise (matches the implicit today-default of
-        // autoDispatch being absent/false).
-        liveValidationAutoDispatch: !!(shared.resolveCheckoutMode(p) === 'live' && p.liveValidation && p.liveValidation.autoDispatch === true),
+        ..._projectCheckoutConfigView(p),
       };
     }),
     autoMode: {
@@ -4113,20 +4100,40 @@ function _resetPreambleCache() {
   _preambleCacheTs = 0;
 }
 
-// Compact one-word-ish label for a project's effective dispatch checkout mode,
-// for CC state surfaces (preamble + refresh). 'worktree' | 'live' |
-// 'hybrid (live-validation: <type>)' so CC can see at a glance whether a project
-// authors in isolated worktrees, runs in-place on the operator tree, or splits
-// the two (coding → worktree, validation type → live). See resolveCheckoutMode.
+function _projectLiveValidationTypeValue(p) {
+  const types = shared.resolveLiveValidationTypes(p);
+  if (types.length === 0) return null;
+  return Array.isArray(p?.liveValidation?.type) ? types : types[0];
+}
+
+function _projectCheckoutConfigView(p) {
+  const checkoutMode = shared.resolveCheckoutMode(p);
+  return {
+    checkoutMode,
+    liveValidationType: checkoutMode === 'live' ? _projectLiveValidationTypeValue(p) : null,
+    liveValidationInvalid: checkoutMode === 'live' && shared.isLiveValidationConfigInvalid(p),
+    liveValidationAutoDispatch: !!shared.resolveLiveValidationAutoDispatchType(p),
+  };
+}
+
+// Compact checkout-mode label for Command Center state surfaces.
 function _projectCheckoutModeLabel(p) {
-  const mode = shared.resolveCheckoutMode(p);
-  if (mode === 'live' && p && p.liveValidation && 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];
+  const {
+    checkoutMode,
+    liveValidationType,
+    liveValidationInvalid,
+  } = _projectCheckoutConfigView(p);
+  if (liveValidationInvalid) {
+    const effectiveTypes = liveValidationType
+      ? (Array.isArray(liveValidationType) ? liveValidationType : [liveValidationType])
+      : [];
+    return `hybrid (invalid liveValidation; effective live types: ${effectiveTypes.join(', ') || 'none'})`;
+  }
+  if (checkoutMode === 'live' && liveValidationType) {
+    const types = Array.isArray(liveValidationType) ? liveValidationType : [liveValidationType];
     return `hybrid (live-validation: ${types.join(', ')})`;
   }
-  return mode;
+  return checkoutMode;
 }
 
 function buildCCStatePreamble() {
@@ -4299,13 +4306,13 @@ function getWorkItemPrRef(input) {
   // afford to be loose because gating would still require explicit
   // operator intent.
   //
-  // FIX-TYPE GATE on the stamp path (W-mqbaby2a000pa8ee): in practice
+  // FIX-LIKE GATE on the stamp path (W-mqbaby2a000pa8ee): in practice
   // the asymmetry leaked — the loose stamp writes to `item.pr_id` (a
   // canonical structured field), and the strict gate later reads
   // `item.pr_id` and sees the loose stamp AS IF it were structured
   // intent. To stop that leak without changing the loose detector
   // (which has other legitimate callers), `copyWorkItemPrFields` now
-  // gates the loose result on `item.type === "fix"`. Non-fix WIs only
+  // gates the loose result through `isFixLikeWorkType`. Other WIs only
   // get stamped from structured fields (incl. references/follow-up).
   // See the comment block on `copyWorkItemPrFields` above for details.
   return shared.extractWorkItemPrRef(input);
@@ -10835,19 +10842,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
           name: p.name,
           localPath: p.localPath || null,
           mainBranch: p.mainBranch || null,
-          // P-a3f9b207 — surface checkoutMode so the Settings UI can pre-fill
-          // the per-project dropdown. resolveCheckoutMode honors the legacy
-          // worktreeMode field; 'worktree' (default) or 'live'.
-          checkoutMode: shared.resolveCheckoutMode(p),
-          // W-mr9mx93d000x1dda — surface the hybrid liveValidation config
-          // (type(s) + autoDispatch) so the Settings → Projects checkout-mode
-          // control can pre-fill its Hybrid sub-panel authoritatively (mirrors
-          // the /api/status project mapping the Projects-bar picker reads).
-          // Only meaningful under checkoutMode:'live'; null/false otherwise.
-          liveValidationType: (shared.resolveCheckoutMode(p) === 'live' && p.liveValidation && p.liveValidation.type)
-            ? p.liveValidation.type
-            : null,
-          liveValidationAutoDispatch: !!(shared.resolveCheckoutMode(p) === 'live' && p.liveValidation && p.liveValidation.autoDispatch === true),
+          ..._projectCheckoutConfigView(p),
           // W-mqtvnnj1000357fa — surface the RAW per-project auto-stash override
           // (true / false / undefined) so the Settings UI can pre-select the
           // tri-state dropdown. Undefined means "use fleet default"