@yemi33/minions 0.1.2393 → 0.1.2395

package/dashboard/js/refresh.js

@@ -141,7 +141,7 @@ const RENDER_VERSIONS = {
   projects: 9,
   notes: 1,
   prd: 3,
-  prs: 3,
+  prs: 4,
   archivedPrds: 1,
   engine: 4,
   version: 1,

package/dashboard/js/render-prs.js

@@ -137,6 +137,12 @@ function stripMarkdown(text) {
     .trim();
 }
 
+function _renderPrMergeConflictBadge(pr) {
+  if (!isPrMergeConflicted(pr)) return '';
+  return '<span class="pr-badge rejected merge-conflict" title="' + escapeHtml(PR_MERGE_CONFLICT_LABEL) +
+    '" aria-label="' + escapeHtml(PR_MERGE_CONFLICT_LABEL) + '">conflict</span>';
+}
+
 function prRow(pr) {
   // Minions review (agent) state — separate from ADO human review
   const sq = pr.minionsReview || {};
@@ -151,6 +157,9 @@ function prRow(pr) {
   const buildTitle = pr.buildStaleMergeCommit
     ? 'ADO has builds on this PR\'s merge ref, but none target the current merge commit (typically after a rebase or target-branch advance). Engine classified from the pre-rebase build set and queued a fresh build (rate limited 30m). See Issue #2747.'
     : (pr._buildStatusDetail || '');
+  const mergeConflictBadge = _renderPrMergeConflictBadge(pr);
+  const mergeStateHtml = mergeConflictBadge ||
+    '<span style="color:var(--muted);font-size:var(--text-base)" aria-label="No merge conflict reported">—</span>';
   const statusClass = pr.status === 'merged' ? 'merged' : pr.status === 'abandoned' ? 'rejected' : pr.status === 'active' ? 'active' : 'draft';
   const statusLabel = pr.status || 'active';
   const branchError = pr._branchResolutionError?.reason || '';
@@ -312,6 +321,7 @@ function prRow(pr) {
     '<td><span class="pr-badge ' + statusClass + '" title="' + escapeHtml(statusLabel) + '">' + escapeHtml(statusLabel) + '</span></td>' +
     '<td><span class="pr-badge ' + reviewClass + '" title="' + escapeHtml(reviewTitle || reviewLabel) + '">' + escapeHtml(reviewLabel) + '</span></td>' +
     '<td><span class="pr-badge ' + buildClass + '" title="' + escapeHtml(buildTitle || buildLabel) + '">' + escapeHtml(buildLabel) + '</span></td>' +
+    '<td>' + mergeStateHtml + '</td>' +
     '<td><span class="' + branchClass + '" title="' + escapeHtml(branchError || branchLabel) + '">' + escapeHtml(branchLabel) + '</span>' + pendingReasonHtml + '</td>' +
     '<td><span class="pr-agent" title="' + escapeHtml(agentText) + '">' + escapeHtml(agentText) + '</span></td>' +
     '<td>' + reviewerCell + '</td>' +
@@ -323,7 +333,7 @@ function prRow(pr) {
 }
 
 // Explicit per-column widths keep the PR table from ballooning when titles or
-// branches are long. Total ≈1455px → table grows past viewport on narrow
+// branches are long. Total 1600px -> table grows past viewport on narrow
 // windows and the .pr-table-wrap--prs container scrolls horizontally inside
 // the viewport (sticky scrollbar — see styles.css).
 const PRS_COLGROUP =
@@ -333,6 +343,7 @@ const PRS_COLGROUP =
     '<col style="width:110px">' +   // Status
     '<col style="width:130px">' +   // Review
     '<col style="width:130px">' +   // Build
+    '<col style="width:120px">' +   // Merge conflict
     '<col style="width:200px">' +   // Branch
     '<col style="width:140px">' +   // Agent
     '<col style="width:140px">' +   // Signed Off By
@@ -345,7 +356,7 @@ function prTableHtml(rows) {
   return '<div class="pr-table-wrap pr-table-wrap--prs"><table class="pr-table pr-table--prs">' +
     PRS_COLGROUP +
     '<thead><tr>' +
-    '<th>PR</th><th>Title</th><th>Status</th><th>Review</th><th>Build</th><th>Branch</th><th>Agent</th><th>Signed Off By</th><th>Observe</th><th>Created</th><th></th>' +
+    '<th>PR</th><th>Title</th><th>Status</th><th>Review</th><th>Build</th><th>Merge</th><th>Branch</th><th>Agent</th><th>Signed Off By</th><th>Observe</th><th>Created</th><th></th>' +
     '</tr></thead><tbody>' + rows + '</tbody></table></div>';
 }
 
@@ -474,11 +485,13 @@ function _renderPrDetail(pr) {
   const statusClass = statusLabel === 'merged' ? 'pr-merged' :
                       statusLabel === 'abandoned' ? 'pr-abandoned' :
                       statusLabel === 'draft' ? 'draft' : 'pr-active';
+  const mergeConflictBadge = _renderPrMergeConflictBadge(pr);
 
   const badges =
     '<span class="pr-badge ' + statusClass + '" title="status">' + escapeHtml(String(statusLabel)) + '</span> ' +
     '<span class="pr-badge ' + reviewClass + '" title="review">' + escapeHtml(String(reviewLabel)) + '</span> ' +
-    '<span class="pr-badge ' + buildClass + '" title="build">' + escapeHtml(String(buildLabel)) + '</span>';
+    '<span class="pr-badge ' + buildClass + '" title="build">' + escapeHtml(String(buildLabel)) + '</span>' +
+    (mergeConflictBadge ? ' ' + mergeConflictBadge : '');
 
   // Linked WIs — join via item._pr === pr.id (stamped by engine/queries.js).
   const wis = (window._lastWorkItems) || [];
@@ -845,4 +858,20 @@ async function resumeWorktreeHeldPause(btn) {
   }
 }
 
-window.MinionsPrs = { prRow, prTableHtml, renderPrs, prPrev, prNext, openAllPrs, openModal, openAddPrModal, openPrDetail, unlinkPr, togglePrObserve, resumePausedCause, resumeBuildFixIneffective, resumeWorktreeHeldPause };
+window.MinionsPrs = {
+  prRow,
+  prTableHtml,
+  renderPrs,
+  renderPrDetail: _renderPrDetail, // exported for testing
+  prPrev,
+  prNext,
+  openAllPrs,
+  openModal,
+  openAddPrModal,
+  openPrDetail,
+  unlinkPr,
+  togglePrObserve,
+  resumePausedCause,
+  resumeBuildFixIneffective,
+  resumeWorktreeHeldPause
+};

package/dashboard/shared/pr-merge-state.js

@@ -0,0 +1,18 @@
+// Shared by the classic PR table/detail and the slim activity-card renderer.
+// `_mergeConflict` is the provider-normalized signal persisted by both pollers;
+// mergeable must still be explicitly false so null/unknown polls never show a
+// stale conflict and a later mergeable poll removes the badge immediately.
+const PR_MERGE_CONFLICT_LABEL = 'Merge conflict: update the source branch or resolve conflicts before this pull request can merge.';
+
+function isPrMergeConflicted(pr) {
+  if (!pr || (pr.status !== 'active' && pr.status !== 'linked')) return false;
+  if (pr.mergeable !== false) return false;
+
+  var mergeStateStatus = typeof pr.mergeStateStatus === 'string'
+    ? pr.mergeStateStatus.trim().toLowerCase()
+    : '';
+  if (mergeStateStatus === 'blocked') return false;
+  if (mergeStateStatus === 'dirty') return true;
+
+  return pr._mergeConflict === true;
+}

package/dashboard/slim/js/history.js

@@ -382,14 +382,23 @@
     titleEl.textContent = title;
     bodyTop.appendChild(titleEl);
 
-    // Status row — grid col 2, row 2 (aligns with rail-bottom). A single
-    // tile-chip, the same pill component (and color classes) as the PR list.
+    // Status row — grid col 2, row 2 (aligns with rail-bottom). Uses the same
+    // pill component for lifecycle status and the independently-derived
+    // merge-conflict state.
     var statusRow = document.createElement('div');
     statusRow.className = 'completions-card-pr-status';
     var chip = document.createElement('span');
     chip.className = 'tile-chip ' + cls;
     chip.textContent = p.status || '—';
     statusRow.appendChild(chip);
+    if (isPrMergeConflicted(p)) {
+      var conflictChip = document.createElement('span');
+      conflictChip.className = 'tile-chip red merge-conflict';
+      conflictChip.textContent = 'conflict';
+      conflictChip.title = PR_MERGE_CONFLICT_LABEL;
+      conflictChip.setAttribute('aria-label', conflictChip.title);
+      statusRow.appendChild(conflictChip);
+    }
 
     card.appendChild(rail);
     card.appendChild(bodyTop);

package/dashboard/slim/styles.css

@@ -1602,8 +1602,8 @@
     }
     .completions-card-chip-pr:hover { filter: brightness(1.2); }
     /* PR card status row — occupies the same grid cell as the lineage row
-       (col 2, row 2) so the rail-bottom time aligns with it. Holds a single
-       left-aligned .tile-chip reusing the PR-list pill styling. */
+       (col 2, row 2) so the rail-bottom time aligns with it. Holds lifecycle
+       and optional conflict chips using the PR-list pill styling. */
     .completions-card-pr-status {
       grid-column: 2;
       display: flex;

package/dashboard/styles.css

@@ -330,12 +330,12 @@
      ellipsis overflow, and the horizontal scrollbar is pinned inside the
      viewport via a bounded-height container on the standalone /prs page so
      it stays reachable without scrolling to the bottom of a tall table. */
-  .pr-table--prs { table-layout: fixed; width: 100%; min-width: 1455px; }
+  .pr-table--prs { table-layout: fixed; width: 100%; min-width: 1600px; }
   .pr-table--prs th, .pr-table--prs td { overflow: hidden; text-overflow: ellipsis; }
-  /* W-mqv5ccn7 — the Status pill (e.g. ABANDONED) must never ellipsis-truncate
-     its own label; let the Status cell (8th column) render its pill in full
+  /* W-mqv5ccn7 — the Signed Off By value must never ellipsis-truncate
+     its own label; let the reviewer cell (9th column) render in full
      rather than inheriting the shared cell-level clip above. */
-  .pr-table--prs td:nth-child(8) { overflow: visible; }
+  .pr-table--prs td:nth-child(9) { overflow: visible; }
   .pr-table--prs th:last-child, .pr-table--prs td:last-child { width: auto; min-width: 0; }
   .pr-table--prs .pr-title { display: block; max-width: 100%; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
   .pr-table--prs .pr-agent { display: inline-block; max-width: 100%; overflow: hidden; text-overflow: ellipsis; vertical-align: middle; white-space: nowrap; }

package/dashboard-build.js

@@ -8,6 +8,7 @@ const shared = require('./engine/shared');
 const { safeRead } = shared;
 
 const MINIONS_DIR = __dirname;
+const DASHBOARD_SHARED_JS = ['pr-merge-state'];
 
 function buildDashboardHtml() {
   const dashDir = path.join(MINIONS_DIR, 'dashboard');
@@ -52,6 +53,10 @@ function buildDashboardHtml() {
     'confirm-dialog', 'modal', 'modal-qa', 'settings', 'qa', 'fre', 'refresh'
   ];
   let jsHtml = '';
+  for (const f of DASHBOARD_SHARED_JS) {
+    const content = safeRead(path.join(dashDir, 'shared', f + '.js'));
+    jsHtml += `\n// ─── shared/${f}.js ────────────────────────────────────────\n${content}\n`;
+  }
   for (const f of jsFiles) {
     const content = safeRead(path.join(dashDir, 'js', f + '.js'));
     jsHtml += `\n// ─── ${f}.js ────────────────────────────────────────\n${content}\n`;
@@ -87,6 +92,7 @@ function _slimSourcePaths(slimDir) {
     path.join(slimDir, 'layout.html'),
     path.join(slimDir, 'styles.css'),
     path.join(slimDir, 'body.html'),
+    ...DASHBOARD_SHARED_JS.map(f => path.join(MINIONS_DIR, 'dashboard', 'shared', f + '.js')),
     ...SLIM_JS_ORDER.map(f => path.join(slimDir, 'js', f + '.js')),
   ];
 }

package/dashboard.js

@@ -1796,6 +1796,10 @@ function buildDashboardHtml() {
     'confirm-dialog', 'modal', 'modal-qa', 'settings', 'qa', 'fre', 'refresh'
   ];
   let jsHtml = '';
+  for (const f of ['pr-merge-state']) {
+    const content = safeRead(path.join(dashDir, 'shared', f + '.js'));
+    jsHtml += `\n// ─── shared/${f}.js ────────────────────────────────────────\n${content}\n`;
+  }
   for (const f of jsFiles) {
     const content = safeRead(path.join(dashDir, 'js', f + '.js'));
     jsHtml += `\n// ─── ${f}.js ────────────────────────────────────────\n${content}\n`;

package/engine/lifecycle.js

@@ -2629,7 +2629,7 @@ function normalizePrFixBranchName(branch) {
 }
 
 function getPrFixBaselineHead(pr) {
-  return String(pr?.headSha || pr?._adoSourceCommit || pr?._adoHeadCommit || '').trim();
+  return String(pr?.headRefOid || pr?.headSha || pr?._adoSourceCommit || pr?._adoHeadCommit || '').trim();
 }
 
 function findPrFixWorktree(meta, project, config) {
@@ -5962,7 +5962,14 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
   }
   if (effectiveSuccess && !skipDoneStatus) {
     // Coding WIs and direct PR-sourced fix dispatches share this follow-up path.
-    try { autoDispatchLiveValidationWi(meta, config, dispatchItem); } catch (err) { log('warn', `autoDispatchLiveValidationWi: ${err.message}`); }
+    const verifiedHeadSha = prFixBranchChange?.evidence === 'remote-head'
+      ? prFixBranchChange.afterHead
+      : '';
+    try {
+      autoDispatchLiveValidationWi(meta, config, dispatchItem, { verifiedHeadSha });
+    } catch (err) {
+      log('warn', `autoDispatchLiveValidationWi: ${err.message}`);
+    }
   }
   // Failure retry is handled by completeDispatch in dispatch.js — not duplicated here.
   // Only clear _decomposing flag on failure so decompose items don't get permanently stuck.
@@ -6943,9 +6950,9 @@ function collapseAllDuplicatePrRecords(config) {
 // always a canonical `test` WI with the PR-focused `build-and-test` playbook;
 // liveValidation.type controls routing, not the semantic type of the task.
 //
-// Deduplicates per codingWiId: any non-terminal WI with
-// meta.liveValidationFor === codingWiId blocks a second dispatch, so only one
-// validation task is ever in flight per coding completion.
+// Deduplicates both per codingWiId and per canonical PR source revision. This
+// keeps concurrent/repeated fixes for one unchanged PR head from queueing
+// duplicate validations while allowing a fresh validation after the head moves.
 //
 // W-mr9u39az000db5c2 — guard against a self-referential recursive cascade.
 // When liveValidation.type overlaps with a coding WI's own type set (e.g.
@@ -6970,7 +6977,7 @@ const ELIGIBLE_LIVE_VALIDATION_TYPES = new Set([
   WORK_TYPE.BUILD_FIX_COMPLEX,
 ]);
 
-function autoDispatchLiveValidationWi(meta, config, dispatchItem = null) {
+function autoDispatchLiveValidationWi(meta, config, dispatchItem = null, options = {}) {
   const item = meta?.item || null;
   const sourceType = item?.type || dispatchItem?.type || null;
   const sourceKey = item?.id || dispatchItem?.id || null;
@@ -7033,27 +7040,48 @@ function autoDispatchLiveValidationWi(meta, config, dispatchItem = null) {
   const prTarget = prUrl || (prId != null ? String(prId) : null);
   if (!prTarget) return;
 
+  const prIdentityRef = {
+    id: prId != null ? String(prId) : prTarget,
+    url: prUrl || '',
+  };
+  let currentPr = typeof prRef === 'object' ? prRef : null;
+  try {
+    currentPr = shared.findPrRecord(shared.readPullRequests(project), prIdentityRef, project) || currentPr;
+  } catch (err) {
+    log('warn', `liveValidation: could not resolve tracked PR ${prTarget}: ${err.message}`);
+  }
+  const liveValidationPrId = shared.getPrIdentityKey(currentPr || prIdentityRef, project);
+  if (!liveValidationPrId) return;
+  const liveValidationHeadSha = String(options?.verifiedHeadSha || '').trim()
+    || getPrFixBaselineHead(currentPr);
+
   const codingWiId = sourceKey;
   const wiScope = item ? resolveWorkItemScope(meta) : projectName;
   if (!wiScope) return;
 
   try {
-    mutateWorkItems(wiScope, items => {
+    mutateWorkItems(wiScope, (items, comparisonItems) => {
       if (!Array.isArray(items)) return items;
 
-      // Dedup: only one validation WI in flight per coding WI. Any non-terminal
-      // WI already tracking this coding WI (meta.liveValidationFor) blocks a
-      // second dispatch, regardless of its validation type. (Back-compat: WIs
-      // created before meta.liveValidationType existed are matched too, since
-      // we key solely on liveValidationFor.)
-      const existing = items.find(i =>
-        i &&
-        i.meta &&
-        i.meta.liveValidationFor === codingWiId &&
-        !PLAN_TERMINAL_STATUSES.has(i.status)
-      );
+      // Keep the source-WI guard and revision guard in this same mutation as the
+      // insert, and compare both supported scopes while the SQLite write
+      // transaction is held. Legacy live-validation WIs predate the persisted
+      // revision fields, so derive their identity from structured PR fields and
+      // conservatively treat a missing head as matching until terminal.
+      const existing = comparisonItems.find(i => {
+        if (!i?.meta?.liveValidationFor || PLAN_TERMINAL_STATUSES.has(i.status)) return false;
+        if (i.meta.liveValidationFor === codingWiId) return true;
+
+        const existingPrRef = i.meta.liveValidationPrId || shared.extractStructuredWorkItemPrRef(i);
+        if (!existingPrRef) return false;
+        const existingPrId = shared.getPrIdentityKey(existingPrRef, project);
+        if (existingPrId !== liveValidationPrId) return false;
+
+        const existingHeadSha = String(i.meta.liveValidationHeadSha || '').trim();
+        return !existingHeadSha || !liveValidationHeadSha || existingHeadSha === liveValidationHeadSha;
+      });
       if (existing) {
-        log('info', `liveValidation: dedup — non-terminal validation WI ${existing.id} already exists for ${codingWiId}`);
+        log('info', `liveValidation: dedup — non-terminal validation WI ${existing.id} blocks another validation for ${codingWiId} (${liveValidationPrId}@${liveValidationHeadSha || 'unknown'})`);
         return items;
       }
 
@@ -7081,6 +7109,8 @@ function autoDispatchLiveValidationWi(meta, config, dispatchItem = null) {
         meta: {
           liveValidationFor: codingWiId,
           liveValidationType: validationType,
+          liveValidationPrId,
+          ...(liveValidationHeadSha ? { liveValidationHeadSha } : {}),
           playbook: 'build-and-test',
           ...(dispatchItem?.id ? { sourceDispatchId: dispatchItem.id } : {}),
         },
@@ -7093,7 +7123,7 @@ function autoDispatchLiveValidationWi(meta, config, dispatchItem = null) {
       items.push(validationWi);
       log('info', `liveValidation: auto-dispatched validation WI ${validationWi.id} (type=${validationType}) for coding WI ${codingWiId}`);
       return items;
-    });
+    }, { readScopes: ['central', projectName] });
   } catch (err) {
     log('warn', `autoDispatchLiveValidationWi for ${codingWiId}: ${err.message}`);
   }

package/engine/shared.js

@@ -7702,12 +7702,17 @@ function readWorkItems(source = null) {
   return require('./work-items-store').readWorkItemsForScope(stateScope(source));
 }
 
-function mutateWorkItems(source, mutator) {
+function mutateWorkItems(source, mutator, opts = {}) {
   const store = require('./work-items-store');
-  const { wrote, result } = store.applyWorkItemsMutation(stateScope(source), (items) => {
+  const scope = stateScope(source);
+  const normalizedOpts = { ...opts };
+  if (Array.isArray(opts.readScopes)) {
+    normalizedOpts.readScopes = opts.readScopes.map(stateScope);
+  }
+  const { wrote, result } = store.applyWorkItemsMutation(scope, (items, comparisonItems) => {
     if (!Array.isArray(items)) items = [];
-    return mutator(items) || items;
-  });
+    return mutator(items, comparisonItems) || items;
+  }, normalizedOpts);
   if (wrote) {
     try { require('./db-events').emitStateEvent('work_items'); } catch { /* optional */ }
     try { require('./queries').invalidateWorkItemsCache(); } catch { /* queries not loaded */ }

package/engine/work-items-store.js

@@ -128,13 +128,14 @@ function _applyWorkItemsDiff(db, diff) {
 
 // Apply a mutation to the work-items array for a given scope. Wrapped in
 // a single transaction so the diff and apply can't race against a
-// concurrent reader/writer.
+// concurrent reader/writer. Optional readScopes are exposed to the mutator
+// as a combined comparison set; only target-scope mutations are persisted.
 //
 // Returns { wrote, result }:
 //   wrote  — true iff at least one INSERT/UPDATE/DELETE landed
 //   result — the post-mutation array (legacy return shape of
 //            mutateJsonFileLocked)
-function applyWorkItemsMutation(scope, mutator, opts) {
+function applyWorkItemsMutation(scope, mutator, opts = {}) {
   const { getDb, withTransaction } = require('./db');
   const db = getDb();
 
@@ -144,8 +145,14 @@ function applyWorkItemsMutation(scope, mutator, opts) {
     // added by readAllWorkItems only and would round-trip as garbage into
     // the data column otherwise.
     for (const wi of before) { if (wi && wi._source) delete wi._source; }
+    const comparisonItems = [...before];
+    const readScopes = Array.isArray(opts.readScopes) ? opts.readScopes : [];
+    for (const readScope of new Set(readScopes)) {
+      if (readScope === scope) continue;
+      comparisonItems.push(...readWorkItemsForScope(readScope));
+    }
     const beforeSnapshot = JSON.parse(JSON.stringify(before));
-    const next = mutator(before);
+    const next = mutator(before, comparisonItems);
     const after = (next === undefined || next === null)
       ? before
       : (Array.isArray(next) ? next : before);

package/package.json

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