@yemi33/minions 0.1.2322 → 0.1.2324

package/dashboard/js/render-other.js

@@ -69,8 +69,24 @@ function _renderProjectBranch(p) {
     ? ' <span class="muted">→ ' + mainBranch + '</span>'
     : '';
   const detachedSuffix = p.gitDetached ? ' <span class="muted">(detached)</span>' : '';
+  // opg-microsoft/minions#664 — the counts are always vs origin/<comparator>
+  // (configured mainBranch, falling back to remoteDefaultBranch; see
+  // engine/queries.js _probeProjectGitStatus), never vs the checked-out
+  // branch's own upstream. When branchDiffersFromMain the bare "↑N ↓M" chip
+  // reads as ambiguous (looks like it could be vs the current branch's
+  // tracking ref), so append the comparator name to the VISIBLE text too —
+  // not just the hover title — so the disambiguation doesn't require a
+  // hover. Skip the suffix when the checked-out branch IS the comparator
+  // since there's nothing to disambiguate.
+  const comparatorBranch = mainBranch || remoteDefault;
+  // Deliberately separate from branchDiffersFromMain (which only fires when a
+  // configured mainBranch is set, driving the "→ main" suffix): the ahead/
+  // behind comparator falls back to remoteDefaultBranch too, so the chip must
+  // disambiguate against whichever one actually produced the counts.
+  const branchDiffersFromComparator = !!(comparatorBranch && p.gitBranch !== (p.mainBranch || p.remoteDefaultBranch));
+  const comparatorSuffix = branchDiffersFromComparator ? ' vs ' + comparatorBranch : '';
   const aheadBehind = (ahead !== null && behind !== null && (ahead > 0 || behind > 0))
-    ? ' <span class="project-ab" title="' + escHtml('Ahead ' + ahead + ' / behind ' + behind + ' vs origin/' + (p.mainBranch || p.remoteDefaultBranch)) + '">↑' + ahead + ' ↓' + behind + '</span>'
+    ? ' <span class="project-ab" title="' + escHtml('Ahead ' + ahead + ' / behind ' + behind + ' vs origin/' + (p.mainBranch || p.remoteDefaultBranch)) + '">↑' + ahead + ' ↓' + behind + comparatorSuffix + '</span>'
     : '';
   // Warning chip surfaces when the configured main disagrees with the remote
   // default branch (the #2732 case: config=master, origin/HEAD=main) OR when

package/dashboard/js/render-prs.js

@@ -202,8 +202,13 @@ function prRow(pr) {
   // clearly-labeled indicator — a still-red build after an unchanged fix
   // attempt usually means the failure isn't fixable by another agent pass
   // (flaky infra, external outage, etc.), hence "infra issue suspected".
-  // No resume action is wired here (clearing this record is an engine-side
-  // change out of scope for this UI-only follow-up) — informational only.
+  // Issue #671 — clicking resumes it via /api/pull-requests/clear-build-fix-ineffective
+  // (resumeBuildFixIneffective below), which clears _buildFixIneffective so
+  // BUILD_FAILURE auto-fix dispatch can resume. A new push already resets
+  // this pause automatically (see shared.isBuildFixIneffectivePaused); the
+  // click handler exists for the case where an operator has already
+  // confirmed (e.g. a fresh CI run queued against a rebased/retried head)
+  // and doesn't want to wait for the next poll to notice.
   var buildFixIneffective = pr._buildFixIneffective;
   if (buildFixIneffective && typeof buildFixIneffective === 'object' && buildFixIneffective.paused === true) {
     var bfiTitle = 'Build-fix reported no branch change, and a live CI re-poll confirmed the build is still "'
@@ -211,11 +216,14 @@ function prRow(pr) {
       + (buildFixIneffective.headSha || 'unknown head') + ') after '
       + (buildFixIneffective.count || '?') + ' ineffective attempt(s). Reason: '
       + (buildFixIneffective.reason || 'unknown')
-      + '. A new push to this branch will reset this pause.';
-    pausedChips += ' <span class="pr-badge rejected pr-build-fix-ineffective-chip" '
-      + 'style="font-size:var(--text-xs)" '
-      + 'title="' + escapeHtml(bfiTitle) + '">'
-      + '⏸ infra issue suspected ▶</span>';
+      + '. A new push to this branch will reset this pause automatically, or click to resume now.';
+    pausedChips += ' <button class="pr-badge rejected pr-build-fix-ineffective-chip" '
+      + 'style="font-size:var(--text-xs);cursor:pointer;border:none" '
+      + 'title="' + escapeHtml(bfiTitle) + '" '
+      + 'data-pr-id="' + escapeHtml(String(pr.id || '')) + '" '
+      + 'data-pr-head-sha="' + escapeHtml(String(buildFixIneffective.headSha || '')) + '" '
+      + 'onclick="event.stopPropagation();resumeBuildFixIneffective(this)">'
+      + '⏸ infra issue suspected ▶</button>';
   }
   const titleText = pr.title || 'Untitled';
   // Polish (W-mqv5ccn7): flatten Markdown in the body so the preview shows
@@ -749,4 +757,38 @@ async function resumePausedCause(btn) {
   }
 }
 
-window.MinionsPrs = { prRow, prTableHtml, renderPrs, prPrev, prNext, openAllPrs, openModal, openAddPrModal, openPrDetail, unlinkPr, togglePrObserve, resumePausedCause };
+// Issue #671 — resume a paused build-fix-ineffective ("infra issue
+// suspected") pause. Mirrors resumePausedCause above but targets the
+// headSha-keyed _buildFixIneffective record via its own endpoint. Sends the
+// headSha the chip was rendered with so the server can reject the clear as
+// stale if the pause has since moved to a different commit.
+async function resumeBuildFixIneffective(btn) {
+  if (!btn || btn.disabled) return;
+  const prId = btn.dataset.prId;
+  const headSha = btn.dataset.prHeadSha || '';
+  if (!prId) return;
+  if (!confirm('Resume build-fix automation on ' + prId + '?\n\nThis clears the "infra issue suspected" pause so the engine can re-dispatch build fixes on the next discovery pass.')) return;
+  btn.disabled = true;
+  const prevDisplay = btn.style.display;
+  btn.style.display = 'none';
+  showToast('pr-toast', 'Resumed build-fix automation on ' + prId, true);
+  try {
+    const res = await fetch('/api/pull-requests/clear-build-fix-ineffective', {
+      method: 'POST', headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ prId, headSha })
+    });
+    if (!res.ok) {
+      const d = await res.json().catch(() => ({}));
+      btn.style.display = prevDisplay;
+      btn.disabled = false;
+      showToast('pr-toast', 'Failed: ' + (d.error || 'unknown'), false);
+      return;
+    }
+  } catch (e) {
+    btn.style.display = prevDisplay;
+    btn.disabled = false;
+    showToast('pr-toast', 'Error: ' + e.message, false);
+  }
+}
+
+window.MinionsPrs = { prRow, prTableHtml, renderPrs, prPrev, prNext, openAllPrs, openModal, openAddPrModal, openPrDetail, unlinkPr, togglePrObserve, resumePausedCause, resumeBuildFixIneffective };

package/dashboard/slim/body.html

@@ -231,7 +231,12 @@
      the standard TILE_VIEWS path in modals-tiles.js#renderPlansBody. There is no
      slim-specific Plans/PRD flyout markup anymore (W-mr28ko750010199f / "reuse,
      don't fork"): the classic /plans screen is the single source of truth for the
-     Plans + PRD tabs and every lifecycle action. -->
+     Plans + PRD tabs and every lifecycle action.
+     The "Active PRs" cockpit tile follows the same iframe-embed pattern
+     (W-mr3l7y0m0007102a): it opens the LITERAL classic /prs screen in a chrome-off
+     iframe (/prs?embed=1) via modals-tiles.js#renderPrsBody, so the full PR
+     filter/sort UI + row actions (comment/track/link/pr-action) are the classic
+     screen — no slim-specific PR list to maintain. -->
 
 <!-- Pin editor — create (Pin Content action / "+ Pin") or edit an existing
      note. Submits to POST /api/pinned (create) or /api/pinned/update (edit). -->

package/dashboard/slim/js/modals-tiles.js

@@ -81,17 +81,6 @@
     return card;
   }
 
-  // Parse the org/project slug from a canonical PR id, dropping the host prefix
-  // and the trailing "#<num>". E.g. "ado:office/iss/constellation#5315603" →
-  // "office/iss/constellation", "github:yemi33/minions#2911" → "yemi33/minions".
-  function parsePrSlug(id) {
-    if (!id || typeof id !== 'string') return '';
-    var hash = id.indexOf('#');
-    var head = hash >= 0 ? id.slice(0, hash) : id;
-    var colon = head.indexOf(':');
-    return colon >= 0 ? head.slice(colon + 1) : head;
-  }
-
   // Per-tile body renderers for the detail modal. Each reads the latest status
   // snapshot and fills the modal body; openTileModal looks them up by key.
   function renderEngineTileBody(body, data) {
@@ -160,107 +149,23 @@
     body.appendChild(frame);
   }
 
-  function renderPrTileBody(body, data) {
-    // Emoji glyphs make build/review status scannable at a glance; the
-    // accompanying label keeps the row readable when the glyph alone is
-    // ambiguous (✅ vs ✅, ❌ vs ❌, ⏳ vs 💬). The raw status string also
-    // stays in the title attribute for hover discoverability.
-    // Keyed by normalized (lowercased) status; missing/unknown → ➖.
-    var BUILD_STATUS = {
-      success:     { glyph: '✅', label: 'passing' },
-      succeeded:   { glyph: '✅', label: 'passing' },
-      passing:     { glyph: '✅', label: 'passing' },
-      failing:     { glyph: '❌', label: 'failing' },
-      failed:      { glyph: '❌', label: 'failing' },
-      error:       { glyph: '❌', label: 'failing' },
-      pending:     { glyph: '⏳', label: 'pending' },
-      running:     { glyph: '⏳', label: 'running' },
-      queued:      { glyph: '⏳', label: 'queued' },
-      in_progress: { glyph: '⏳', label: 'in progress' },
-    };
-    var REVIEW_STATUS = {
-      approved:              { glyph: '✅', label: 'approved' },
-      'changes-requested':   { glyph: '❌', label: 'changes requested' },
-      changes_requested:     { glyph: '❌', label: 'changes requested' },
-      'requested-changes':   { glyph: '❌', label: 'changes requested' },
-      rejected:              { glyph: '❌', label: 'rejected' },
-      pending:               { glyph: '💬', label: 'pending' },
-      commented:             { glyph: '💬', label: 'commented' },
-    };
-    function statusSpan(subsystem, raw, table) {
-      var info = table[String(raw || '').toLowerCase()];
-      var glyph = info ? info.glyph : '➖';
-      var label = info ? info.label : (raw ? String(raw) : 'none');
-      var span = document.createElement('span');
-      span.className = 'pr-status';
-      span.textContent = glyph + ' ' + subsystem + ' ' + label;
-      span.title = subsystem + ': ' + (raw || 'unknown');
-      return span;
-    }
-    var prs = Array.isArray(data.pullRequests) ? data.pullRequests : [];
-    if (!prs.length) { tileEmpty(body, 'No tracked pull requests.'); return; }
-    function prCard(p) {
-      var num = p.prNumber || p.number || p.id;
-      var build = p.buildStatus || '';
-      var review = p.reviewStatus || '';
-      var cls = p.status === 'merged' ? 'green'
-              : (build === 'failing' ? 'red'
-              : ((p.status === 'active' || p.status === 'linked') ? 'blue' : ''));
-      var statusText = document.createElement('span');
-      statusText.textContent = p.status || 'unknown';
-      return tileCard({
-        title: (num ? '#' + num + ' ' : '') + (p.title || '(untitled PR)'),
-        // Project slug first (under title), then build/review row below — the
-        // project is the strongest disambiguator across PRs and benefits from
-        // being adjacent to the title.
-        subtle: parsePrSlug(p.id),
-        subtleBeforeMeta: true,
-        metaNodes: [statusText, statusSpan('build', build, BUILD_STATUS), statusSpan('review', review, REVIEW_STATUS)],
-        chip: { text: p.status || '—', cls: cls },
-        href: p.url || null,
-      });
-    }
-    // Partition once into three fixed buckets (status normalized to lowercase),
-    // preserving each PR's relative order within its bucket. Mirrors shared
-    // PR_STATUS (active/merged/abandoned/closed/linked); anything that does not
-    // match the merged/abandoned buckets defaults to Active so a PR with an
-    // unexpected status never silently disappears.
-    var buckets = { active: [], merged: [], abandoned: [] };
-    prs.forEach(function(p) {
-      var s = String(p.status || '').toLowerCase();
-      if (s === 'abandoned') buckets.abandoned.push(p);
-      else if (s === 'merged' || s === 'completed' || s === 'closed') buckets.merged.push(p);
-      else buckets.active.push(p);
-    });
-    // Fixed section order: Active (open) → Merged / Completed → Abandoned.
-    // Empty sections are omitted entirely.
-    var sections = [
-      { label: 'Active', prs: buckets.active, open: true },
-      { label: 'Merged / Completed', prs: buckets.merged, open: false },
-      { label: 'Abandoned', prs: buckets.abandoned, open: false },
-    ];
-    sections.forEach(function(section) {
-      if (!section.prs.length) return;
-      var details = document.createElement('details');
-      details.className = 'tile-section';
-      if (section.open) details.open = true;
-      var summary = document.createElement('summary');
-      summary.className = 'tile-section-summary';
-      var label = document.createElement('span');
-      label.className = 'tile-section-label';
-      label.textContent = section.label;
-      var count = document.createElement('span');
-      count.className = 'tile-section-count';
-      count.textContent = '(' + section.prs.length + ')';
-      summary.appendChild(label);
-      summary.appendChild(count);
-      details.appendChild(summary);
-      var sectionBody = document.createElement('div');
-      sectionBody.className = 'tile-section-body';
-      section.prs.forEach(function(p) { sectionBody.appendChild(prCard(p)); });
-      details.appendChild(sectionBody);
-      body.appendChild(details);
-    });
+  // Pull-requests tile body — reuses the LITERAL classic dashboard /prs screen
+  // instead of a slim-specific bucketed PR list, so there is one PRs UI, not two
+  // (W-mr3l7y0m0007102a / "reuse, don't fork" — mirrors renderQueuedWorkBody for
+  // the Work tile and renderPlansBody for the Plans tile). Slim and classic are
+  // two separate IIFE bundles with no shared scope, so we embed the real /prs
+  // screen in an iframe with the chrome-off ?embed=1 mode. The iframed page IS
+  // the classic screen — the full PR list with every filter/sort + row action
+  // (comment/track/link/pr-action), backed by the same /api/status pullRequests
+  // data + endpoints — with zero duplicated rendering logic. Classic is reachable
+  // at /prs even with slim-ux ON (only / is taken over). Built with createElement
+  // (no innerHTML) to satisfy the dashboard no-unsanitized lint gate.
+  function renderPrsBody(body) {
+    var frame = document.createElement('iframe');
+    frame.className = 'slim-prs-embed';
+    frame.src = '/prs?embed=1';
+    frame.title = 'Pull Requests';
+    body.appendChild(frame);
   }
 
   function renderWatchTileBody(body, data) {
@@ -283,7 +188,7 @@
     dispatches: { title: 'Active dispatches', render: function(body, data) { renderDispatchTileBody(body, data, true); } },
     queued:     { title: 'Queued work',       render: function(body) { renderQueuedWorkBody(body); } },
     plans:      { title: 'Plans',             render: function(body) { renderPlansBody(body); } },
-    prs:        { title: 'Pull requests',     render: renderPrTileBody },
+    prs:        { title: 'Pull requests',     render: function(body) { renderPrsBody(body); } },
     watches:    { title: 'Watches',           render: renderWatchTileBody },
   };
 
@@ -304,11 +209,13 @@
     // The "+ Link PR" header chip only applies to the PR list.
     var headerChip = document.getElementById('slim-tile-modal-linkpr');
     if (headerChip) headerChip.style.display = (key === 'prs') ? '' : 'none';
-    // The queued + plans tiles embed a full classic screen (/work, /plans) in an
-    // iframe — widen the modal + drop the body padding so the embedded screen
-    // gets real estate. Both reuse the shared wide-modal treatment.
+    // The queued, plans + prs tiles embed a full classic screen (/work, /plans,
+    // /prs) in an iframe — widen the modal + drop the body padding so the
+    // embedded screen gets real estate. All three reuse the shared wide-modal
+    // treatment.
     modal.classList.toggle('tile-modal--work', key === 'queued');
     modal.classList.toggle('tile-modal--plans', key === 'plans');
+    modal.classList.toggle('tile-modal--prs', key === 'prs');
     view.render(body, lastStatusData || {});
     modal.classList.add('open');
   }

package/dashboard/slim/styles.css

@@ -680,15 +680,19 @@
     /* Cockpit-tile detail modal: list of dispatches / PRs / watches, or a
        key/value engine readout (reuses .agent-detail-row). */
     #slim-tile-modal .modal { width: 720px; max-width: calc(100vw - 32px); }
-    /* W-mqrdggys000f94a4 / W-mr28ko750010199f — the Queued-work + Plans tiles
-       embed a full classic screen (/work, /plans) in an iframe; widen the modal +
-       remove body padding so the embedded screen gets the full width/height. */
+    /* W-mqrdggys000f94a4 / W-mr28ko750010199f / W-mr3l7y0m0007102a — the
+       Queued-work + Plans + PRs tiles embed a full classic screen (/work,
+       /plans, /prs) in an iframe; widen the modal + remove body padding so the
+       embedded screen gets the full width/height. */
     #slim-tile-modal.tile-modal--work .modal,
-    #slim-tile-modal.tile-modal--plans .modal { width: 1180px; }
+    #slim-tile-modal.tile-modal--plans .modal,
+    #slim-tile-modal.tile-modal--prs .modal { width: 1180px; }
     #slim-tile-modal.tile-modal--work .modal-body,
-    #slim-tile-modal.tile-modal--plans .modal-body { padding: 0; }
+    #slim-tile-modal.tile-modal--plans .modal-body,
+    #slim-tile-modal.tile-modal--prs .modal-body { padding: 0; }
     .slim-work-embed,
-    .slim-plans-embed {
+    .slim-plans-embed,
+    .slim-prs-embed {
       display: block; width: 100%; height: calc(100vh - 160px); min-height: 360px;
       border: 0; background: var(--bg);
     }
@@ -711,7 +715,6 @@
     }
     .tile-item-meta { font-size: var(--text-base); color: var(--muted); margin-top: 3px; word-break: break-word; }
     .tile-item-subtle { font-size: var(--text-sm); color: var(--muted); margin-top: 2px; word-break: break-word; }
-    .pr-status { display: inline-block; margin: 0 1px; text-decoration: none; }
     .tile-chip {
       flex: 0 0 auto;
       font-size: var(--text-base); font-weight: 700; letter-spacing: 0.4px; text-transform: uppercase;
@@ -724,26 +727,6 @@
     .tile-chip.blue  { background: rgba(88, 166, 255, 0.12); color: var(--blue);  border-color: var(--blue); }
     .tile-empty { color: var(--muted); font-style: italic; font-size: var(--text-md); }
 
-    /* Collapsible PR sections (Active / Merged-Completed / Abandoned). Uses
-       native <details>/<summary> — no JS wiring needed for the toggle. */
-    .tile-section { margin-bottom: 10px; }
-    .tile-section:last-child { margin-bottom: 0; }
-    .tile-section-summary {
-      display: flex; align-items: center; gap: 6px;
-      cursor: pointer; user-select: none;
-      padding: 4px 2px; margin-bottom: 6px;
-      list-style: none;
-      font-size: var(--text-base); color: var(--muted);
-    }
-    .tile-section-summary::-webkit-details-marker { display: none; }
-    .tile-section-summary::before {
-      content: "▸"; color: var(--muted); font-size: var(--text-sm);
-      transition: transform 0.15s ease;
-    }
-    .tile-section[open] > .tile-section-summary::before { content: "▾"; }
-    .tile-section-label { font-weight: 700; letter-spacing: 0.3px; text-transform: uppercase; color: var(--text); }
-    .tile-section-count { color: var(--muted); }
-
     /* Pinned-context list rows (Knowledge modal → Pinned Context tab). */
     .pinned-row {
       border: 1px solid var(--border);

package/dashboard.js

@@ -28,10 +28,13 @@ const v8 = require('v8');
 const llm = require('./engine/llm');
 const { resolveRuntime } = require('./engine/runtimes');
 
-// Dashboard version stamp — captured at module load so it reflects the code actually running
+// Dashboard version stamp — captured at module load so it reflects the code actually running.
+// codeCommit is read via _readGitHeadShort (defined below — function declarations
+// are hoisted, so the call here resolves fine) instead of spawning a `git`
+// subprocess; see that function's doc comment for the rationale.
 const _dashboardVersion = {
   codeVersion: (() => { try { return require('./package.json').version; } catch {} try { return require('@yemi33/minions/package.json').version; } catch {} return null; })(),
-  codeCommit: (() => { try { return require('child_process').execSync('git rev-parse --short HEAD', { cwd: __dirname, encoding: 'utf8', timeout: 5000, windowsHide: true }).trim(); } catch { return null; } })(),
+  codeCommit: _readGitHeadShort(__dirname).commit,
   startedAt: new Date().toISOString(),
   pid: process.pid,
 };
@@ -2252,13 +2255,16 @@ let _diskVersionCacheTs = 0;
 const DISK_VERSION_TTL = 60000; // re-check every 60s
 
 // Read the short HEAD commit by parsing `.git` directly — NO `git` subprocess.
-// The old `execSync('git rev-parse --short HEAD', { timeout: 5000 })` spawned a
-// synchronous child process on the dashboard's single event loop; under
-// concurrent agent git activity (worktree add/merge holding repo locks) that
-// subprocess could take its full 5s timeout, and because getDiskVersion runs
-// inside the /api/status rebuild, every in-flight poll blocked for that whole
-// window. Reading `.git/HEAD` + the resolved ref (loose ref, then packed-refs
-// fallback) is a couple of tiny synchronous file reads with zero process spawn.
+// The old `execSync('git rev-parse --short HEAD', { timeout: 5000 })` (both here
+// and in the `_dashboardVersion.codeCommit` init near the top of this file)
+// spawned a synchronous child process on the dashboard's single event loop;
+// under concurrent agent git activity (worktree add/merge holding repo locks)
+// that subprocess could take its full 5s timeout, and because getDiskVersion
+// runs inside the /api/status rebuild, every in-flight poll blocked for that
+// whole window. Reading `.git/HEAD` + the resolved ref (loose ref, then
+// packed-refs fallback) is a couple of tiny synchronous file reads with zero
+// process spawn. Function declarations are hoisted, so `_dashboardVersion`'s
+// module-load-time init above can call this even though it's defined here.
 // Returns { commit, isGitRepo }: commit is the 7-char short SHA or null.
 function _readGitHeadShort(repoDir) {
   try {
@@ -3959,6 +3965,7 @@ function _buildSyntheticActionResultsForTurn(turnId, message, requestedAt) {
     if (entry.id) result.id = entry.id;
     if (entry.project) result.project = entry.project;
     if (entry.path) result.path = entry.path;
+    if (entry.duplicate) result.duplicate = true;
     if (Array.isArray(entry.followups) && entry.followups.length) result.followups = entry.followups;
     results.push(result);
   }
@@ -6914,6 +6921,14 @@ const server = http.createServer(async (req, res) => {
       const createResult = createWorkItemWithDedup(wiPath, item);
       if (!createResult.created) {
         const duplicateId = createResult.duplicateOf || createResult.item?.id;
+        // W-mr466ocx000l1191 — record the CC turn creation on the dedup path
+        // too. The API call still succeeded (ok:true) from the caller's
+        // perspective; without this, a CC turn that dispatches a work item
+        // matching an existing one silently loses its confirmation chip
+        // (_buildSyntheticActionResultsForTurn drains an empty list for the
+        // turn, so donePayload.actions/actionResults come back empty even
+        // though the LLM's tool call succeeded).
+        recordCcTurnIfPresent(req, { kind: 'work-item', id: duplicateId, title: item.title, project: item.project || null, duplicate: true });
         return jsonReply(res, 200, { ok: true, id: duplicateId, duplicate: true, duplicateOf: duplicateId });
       }
       recordCcTurnIfPresent(req, { kind: 'work-item', id, title: item.title, project: item.project || null });
@@ -13902,6 +13917,55 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       return jsonReply(res, 200, { ok: true, cleared: cause, prId });
     }},
 
+    // Issue #671 — sibling to clear-paused-cause above, but for the
+    // headSha-keyed `_buildFixIneffective` ("infra issue suspected") pause
+    // (see engine/lifecycle.js#recordBuildFixIneffective), which is tracked
+    // separately from `_noOpFixes` and so isn't reachable via the endpoint
+    // above. Once a fresh CI build is queued against a rebased/retried head,
+    // this lets an operator clear the stale pause without hand-editing
+    // pull-requests.json.
+    { method: 'POST', path: '/api/pull-requests/clear-build-fix-ineffective', desc: 'Resume a paused build-fix-ineffective ("infra issue suspected") pause (issue #671) — clears _buildFixIneffective so BUILD_FAILURE auto-fix dispatch can resume', params: 'prId (canonical host:slug#number), headSha? (optional — if provided, must match the paused record\'s headSha or the clear is rejected as stale)', handler: async (req, res) => {
+      const body = await readBody(req);
+      const prId = typeof body?.prId === 'string' ? body.prId.trim() : '';
+      const headSha = typeof body?.headSha === 'string' ? body.headSha.trim() : '';
+      if (!prId) return jsonReply(res, 400, { error: 'prId required' });
+      reloadConfig();
+      const lifecycle = require('./engine/lifecycle');
+      const prPaths = [
+        ...shared.getProjects(CONFIG).map(p => shared.projectPrPath(p)),
+        shared.centralPullRequestsPath(MINIONS_DIR),
+      ];
+      let prFound = false;
+      let recordCleared = false;
+      let staleHead = false;
+      for (const prPath of prPaths) {
+        if (recordCleared || staleHead) break;
+        shared.mutatePullRequests(prPath, (prs) => {
+          if (!Array.isArray(prs)) return prs;
+          const target = prs.find(p => p && p.id === prId);
+          if (!target) return prs;
+          prFound = true;
+          const record = target._buildFixIneffective;
+          if (!record || typeof record !== 'object') return prs;
+          // If the caller told us which head they saw the pause on (the
+          // dashboard chip stamps this at render time), refuse to clear a
+          // pause that has since moved on to a different head — that would
+          // silently apply a stale click's intent to a newer commit.
+          if (headSha && record.headSha && record.headSha !== headSha) {
+            staleHead = true;
+            return prs;
+          }
+          recordCleared = lifecycle.clearBuildFixIneffective(target);
+          return prs;
+        });
+      }
+      if (!prFound) return jsonReply(res, 404, { error: `PR ${prId} not found` });
+      if (staleHead) return jsonReply(res, 409, { error: `build-fix-ineffective pause on PR ${prId} is for a different head than provided — refresh and retry` });
+      if (!recordCleared) return jsonReply(res, 400, { error: `PR ${prId} has no tracked build-fix-ineffective pause` });
+      invalidateStatusCache();
+      return jsonReply(res, 200, { ok: true, cleared: 'build-fix-ineffective', prId });
+    }},
+
     // ─── P-f3c9d0e7: convenience pause/resume endpoints ─────────────────────
     // Single-call wrappers over `POST /api/settings { engine: { <flag>: bool } }`
     // for the two operator kill-switches:

package/docs/command-center.md

@@ -31,7 +31,7 @@ Canonical envelope (`_buildCcErrorEnvelope` in `dashboard.js`):
 
 **No auto-retry policy.** The backend never re-spawns the LLM after an error envelope. The client never silently resends the user's turn. Retry is a single-click manual action — guards against silent budget burn on `budget-exceeded`, infinite loops on `auth-failure`, and accidental re-charges on `context-limit`. The 429 + reconnect paths (rate-limited fetch retry, SSE reconnect-after-disconnect) remain — those are transport-level, not error-envelope-level.
 
-**Session-reset notices (`sessionReset` / `sessionResetReason`).** The streaming `done` event can carry `sessionReset: true` with a `sessionResetReason` of `promptChanged` (Minions updated its CC prompt template), `runtimeChanged` (CC runtime switched), or `idleReap` (W-mr0qs0vw — the persistent `copilot --acp` worker was killed by the idle reaper after `engine.ccWorkerIdleTimeoutMs` of inactivity, so the next message cold-spawns a fresh session with no memory). Both classic (`dashboard/js/command-center.js`) and slim (`dashboard/slim/js/command-send.js` + `chat.js#appendSystemNotice`) render a centered, muted system notice; for `idleReap` the text is "Context window cleared after inactivity — fresh session started." The idle-reap flag is a one-shot drained per turn via `ccWorkerPool.consumeIdleReapNotice(tabId)`.
+**Session-reset notices (`sessionReset` / `sessionResetReason`).** The streaming `done` event can carry `sessionReset: true` with a `sessionResetReason` of `promptChanged` (Minions updated its CC prompt template), `runtimeChanged` (CC runtime switched), or `idleReap` (W-mr0qs0vw — the persistent `copilot --acp` worker was killed by the idle reaper after `engine.ccWorkerIdleTimeoutMs` of inactivity, so the next message cold-spawns a fresh session with no memory). Both classic (`dashboard/js/command-center.js`) and slim (`dashboard/slim/js/command-send.js` + `chat.js#appendSystemNotice`) render a centered, muted system notice; for `idleReap` the text is "Context window cleared after inactivity — fresh session started." The idle-reap flag is a one-shot drained per turn via `ccWorkerPool.consumeIdleReapNotice(tabId)`. **`ccWorkerIdleTimeoutMs: 0`** is an explicit "never idle-reap" sentinel (W-mr1qbj90000d30bd) — it bypasses the normal `[60000, 28800000]` clamp, maps to an `Infinity` window in `cc-worker-pool.js#setIdleTimeoutMs`, and the warm worker then only dies on an explicit `closeTab`. Settings page exposes this as the "Never idle-reap CC workers" toggle.
 
 ## Image attachments (PL-cc-image-attachments)
 

package/docs/engine-restart.md

@@ -54,6 +54,10 @@ To kill them now, run: node engine.js kill
 
 If an agent is killed as an orphan and the work item retries, cooldowns use exponential backoff (2^failures, max 8x) to prevent spam-retrying broken tasks.
 
+### 5. Crash-Loop Counter + Alert (W-mr2azk6i000y06e0)
+
+The engine.js *process itself* (not an agent) can crash and get auto-respawned by three independent mechanisms: `engine/supervisor.js#checkEngine` (dead-PID), `engine/supervisor.js#checkEngineHung` (stale-heartbeat), and `engine/watchdog.js` (OS-scheduled external recovery); `dashboard.js`'s in-process 30s watchdog also auto-restarts on a dead PID (the user-triggered Restart Engine button is excluded). Each successful respawn calls `shared.recordEngineRespawn(source)`, which appends `{ts, source}` to `control.json`'s `engineRespawns[]` (rolling window, default `CRASH_LOOP_WINDOW_MS` = 10 min). Once respawns within the window reach `CRASH_LOOP_THRESHOLD` (default 3), `control.crashLoopAlert` is set (dashboard-visible via `/api/status`) and a deduped (one-per-day) `notes/inbox/` alert is written; the alert clears automatically once the window rolls past the incident. Override the window/threshold via `MINIONS_CRASH_LOOP_WINDOW_MS` / `MINIONS_CRASH_LOOP_THRESHOLD` env vars.
+
 ## Safe Restart Pattern
 
 ```bash

package/docs/live-checkout-mode.md

@@ -32,7 +32,7 @@ Implementation: `engine.js` builds a `liveProjectsInUse` set from the active dis
 
 Before spawning, `engine/live-checkout.js#prepareLiveCheckout` runs `git status --porcelain` from `project.localPath`. Any output (staged, unstaged, untracked) **returns** an explicit `{ ok:false, reason:'dirty', dirtyFiles:[…] }` result (it does NOT throw), which refuses the dispatch immediately:
 
-- Non-retryable `FAILURE_CLASS.LIVE_CHECKOUT_DIRTY` (added to `engine/dispatch.js`'s `neverRetry` set so the dispatcher never re-spawns mechanically). **Reserved for this confirmed-dirty result only** — a thrown helper/git error is `LIVE_CHECKOUT_FAILED`, see below (#305).
+- Non-retryable `FAILURE_CLASS.LIVE_CHECKOUT_DIRTY` (added to `engine/dispatch.js`'s `neverRetry` set so the dispatcher never re-spawns mechanically). **Reserved for this confirmed-dirty result only** — a thrown helper/git error is `LIVE_CHECKOUT_FAILED`, see below (#305). **Auto-cleanup exception (W-mqzmkoqt000hbca2, #582):** when `liveCheckoutAutoReset` or `liveCheckoutAutoStash` is enabled (per-project or fleet-wide), `spawnAgent` treats the dirty refusal as retryable instead — the engine re-cleans the tree on every attempt, so the two-strike cap below is skipped and the dispatch keeps retrying up to the normal `maxRetries` cap. The `dispatch.js` `neverRetry` entry is kept only as a defensive fallback for callers that omit the explicit `agentRetryable` override.
 - Inbox alert written via `dispatch.writeInboxAlert('live-checkout-dirty-<wi-id>', body)`. The body lists the dirty files verbatim from `git status --porcelain`.
 - Work item stamped with `_pendingReason: 'live_checkout_dirty'` so the dashboard surfaces the block.
 - Completion summary: `live-checkout refused: N dirty file(s) in <localPath>`.
@@ -69,6 +69,9 @@ This is **DESTRUCTIVE** — it permanently discards the operator's uncommitted c
 - **Fleet-wide:** Dashboard → Settings → `Live-checkout auto-reset (fleet-wide)` (`engine.liveCheckoutAutoReset`).
 - **Per-project override:** set `liveCheckoutAutoReset: true|false` on the project object in `config.json` (see the config snippet under *Enabling live mode*). A per-project boolean overrides the fleet-wide default for that project. *(Per-project Settings-UI persistence is deferred — the per-project override is config.json-only for now.)*
 
+#### 2c. Stale `.git/index.lock` self-heal (W-mr3tayu4)
+
+Before any preflight git command runs, `prepareLiveCheckout` calls the shared, age-gated `shared.removeStaleIndexLock(localPath)` to clear a leftover `.git/index.lock` from a crashed/killed git process. Live mode never resets/cleans the operator tree, so nothing else would clear it, and — since `LIVE_CHECKOUT_FAILED` is retryable — every automatic retry used to hit the same stale lock and fail identically forever until an operator deleted it by hand. The remover only touches locks older than 5 minutes, so a lock held by a currently-running git process is never removed out from under it. `engine.js`'s own worktree-mode lock cleanup now delegates to the same shared helper.
 
 ### 3. No auto-pull, no `--force`, no fast-forward
 
@@ -275,6 +278,6 @@ Live-checkout mode is deliberately small. These are NOT supported and will not b
 | `engine/shared.js` — `FAILURE_CLASS.LIVE_CHECKOUT_MID_OPERATION` | Non-retryable refusal class for a mid-operation / detached-HEAD operator tree (in-progress merge/rebase/cherry-pick/revert/bisect or detached HEAD), distinct from the dirty-tree class. Emitted by `spawnAgent`'s mid-op / detached-HEAD refusal block (P-a7f3c1d9; wired P-c5a1f3b8). |
 | `engine/shared.js` — `FAILURE_CLASS.LIVE_CHECKOUT_BLOB_FETCH` | Non-retryable refusal class for an existing-branch checkout that could not hydrate the tree on a blobless GVFS partial clone (auth-less cache fetch, headless) — deterministic, so excluded from mechanical retry (PL-live-checkout-reliability-hardening). |
 | `engine/shared.js` — `FAILURE_CLASS.LIVE_CHECKOUT_WORKTREE_CONFLICT` | Non-retryable refusal class for an existing-branch checkout that refused because the branch is already checked out in another worktree — structural, so excluded from mechanical retry (W-mr28h2j2000y0de1). |
-| `engine.js` — `_liveCheckoutDirtyAttempts` counter | Dedicated two-strike dirty memory (survives the discovery + retry `_pendingReason` scrubs that defeated #434); first dirty failure retries once, second fails non-retryably (PL-live-checkout-reliability-hardening). |
+| `engine.js` — `_liveCheckoutDirtyAttempts` counter | Dedicated two-strike dirty memory (survives the discovery + retry `_pendingReason` scrubs that defeated #434); first dirty failure retries once, second fails non-retryably (PL-live-checkout-reliability-hardening) — **unless** `liveCheckoutAutoReset`/`liveCheckoutAutoStash` is enabled, in which case the two-strike cap is skipped entirely and the dirty failure stays retryable up to `maxRetries` (W-mqzmkoqt000hbca2, #582). |
 | `engine/dispatch.js` — `isRetryableFailureReason` neverRetry | Excludes `LIVE_CHECKOUT_DIRTY`, `LIVE_CHECKOUT_MID_OPERATION`, `LIVE_CHECKOUT_BLOB_FETCH`, and `LIVE_CHECKOUT_WORKTREE_CONFLICT` from mechanical retry. |
 | `engine/timeout.js` header comment | Confirms no special live-mode kill handling. |

package/docs/plan-lifecycle.md

@@ -69,6 +69,10 @@ When all PRD items reach `done` or `failed` status, `checkPlanCompletion()` fire
 3. **PR work item** created for shared-branch plans (to merge the feature branch)
 4. **PRD status** persisted as `completed` with `_completionNotified`; files stay active until manual archive
 
+`checkPlanCompletion()` also **self-heals a stale `completed` PRD**: if a completed plan later gains an unmaterialized item or one of its items regresses off a terminal status, the PRD is reverted to `active` (status flipped, `_completionNotified` cleared) so the materializer recreates the missing work item and the normal completion flow can run again.
+
+**Separate lighter-weight path — `advancePrdStatusOnAllItemsDone()` (P-d7e8f9a1).** Called at the end of `syncPrdFromPrs` on the PR-poll cadence, this independently advances a PRD's top-level `status` to `completed` once every `missing_features` item has both (1) a work item in a `DONE_STATUSES` state and (2) its linked PR merged (or no linked PR, for non-code items). It skips frozen PRDs (`paused`, `rejected`, `awaiting-approval`, `completed`, `archived` — `_PRD_FROZEN_STATUSES`) and writes idempotently via `mutateJsonFileLocked` + `skipWriteIfUnchanged`. Unlike `checkPlanCompletion()`, it does not create the verify task, completion summary, or PR work item — those still only come from the `checkPlanCompletion()` path above.
+
 ## Verification Task
 
 The verification task (`planItemId: "VERIFY"`) is the final step. It:
@@ -118,7 +122,7 @@ The verify agent does not call `archivePlan()`. After the testing guide and any
 
 Manual archive behavior:
 
-1. For PRD JSON files, the dashboard archives them **in-place** in `prd/` — the file is not moved. The JSON is stamped with `archived: true`, `status: "archived"`, and `archivedAt` (Phase 10 step 4.2b). The `.backup` sidecar is left intact since the file keeps its canonical path.
+1. For PRD JSON files, the dashboard archives them **in-place** in `prd/` — the file is not moved. The JSON is stamped with `archived: true`, `status: "archived"`, and `archivedAt` (Phase 10 step 4.2b). **No `.backup` sidecar is written or restored for any `prd/*.json`** — Phase 10 step 4.3 dropped the PRD backup/restore lifecycle entirely (root-level PRDs used to get one to survive the now-retired rename race; SQL is canonical, so a stale `.backup` is pure resurrection fuel, not a safety net).
 2. If the PRD has `source_plan`, the matching `plans/<source>.md` is moved to `plans/archive/<source>.md`.
 3. Pending or queued work items linked to the archived PRD are cancelled with `_cancelledBy: "plan-archived"`; completed work items remain as history.
 4. Plan worktrees are cleaned up by the archive handler/lifecycle cleanup path.

package/engine/consolidation.js

@@ -1153,6 +1153,52 @@ function hasReusableSignal(content) {
   return REUSABLE_SIGNAL_RE.test(content || '');
 }
 
+// ── Engine-alert KB dedup (W-mr3pi9de, sibling of W-mr3lokxs) ────────────────
+// Recurring engine-system alerts (e.g. the worktree-skip-live guard firing
+// across many different worktrees, or the same live-checkout-dirty incident
+// firing every tick) used to be written as full-size KB copies with -2/-3/…
+// numeric suffixes via uniquePath, multiplying storage N times per day.
+// Instead we content-hash each alert and skip writing when a same-hash entry
+// already exists in the target category. The hash is stored in the entry's
+// frontmatter (`alertHash:`) so future passes can dedup against it cheaply.
+
+// Normalized, length-bounded content hash. Collapses whitespace so trivially
+// re-rendered dumps (e.g. differing timestamps) still collapse to one hash.
+function _alertContentHash(content) {
+  const raw = String(content || '');
+  const normalized = raw.replace(/\s+/g, ' ').trim().slice(0, 4000);
+  return crypto.createHash('sha256').update(normalized + ':' + raw.length).digest('hex');
+}
+
+// Read only the leading bytes of a file (frontmatter lives at the very top) so
+// scanning a directory that also holds huge legacy full-body dumps never loads
+// those multi-MB bodies into memory.
+function _readFileHead(fp, bytes = 512) {
+  let fd;
+  try {
+    fd = fs.openSync(fp, 'r');
+    const buf = Buffer.alloc(bytes);
+    const n = fs.readSync(fd, buf, 0, bytes, 0);
+    return buf.slice(0, n).toString('utf8');
+  } catch { return ''; }
+  finally { if (fd !== undefined) { try { fs.closeSync(fd); } catch { /* best-effort */ } } }
+}
+
+// Does an existing KB entry in `dir` already carry this alertHash frontmatter?
+function _alertHashExists(dir, hash) {
+  if (!hash || !dir || !fs.existsSync(dir)) return false;
+  let files;
+  try { files = fs.readdirSync(dir); } catch { return false; }
+  const re = new RegExp(`^alertHash:\\s*${hash}\\s*$`, 'm');
+  for (const f of files) {
+    if (!f.endsWith('.md')) continue;
+    const head = _readFileHead(path.join(dir, f));
+    const fm = head.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (fm && re.test(fm[1])) return true;
+  }
+  return false;
+}
+
 /**
  * Build a condensed KB stub for narrowly-scoped, one-off notes instead of
  * duplicating the full body (issue #604 — classifyToKnowledgeBase was copying
@@ -1223,18 +1269,32 @@ async function classifyToKnowledgeBase(items, config) {
     // Reserve full-body KB copies for content that's actually general/reusable
     // (patterns, conventions, gotchas); narrowly-scoped one-off notes get a
     // condensed stub + link back to the archived note instead (issue #604).
-    const reusable = category === 'conventions' || hasReusableSignal(content);
+    //
+    // W-mr3pi9de — engine-authored system alerts (worktree-skip-live guard
+    // fires, dirty-tree refusals, blocked dispatches, managed-spawn failures)
+    // are operational noise, NEVER durable reusable knowledge. Force them
+    // non-reusable regardless of category or any incidental heading-shaped
+    // line in the body that would otherwise trip hasReusableSignal, and
+    // content-hash-dedup recurring identical/near-identical incidents instead
+    // of appending -2/-3 full copies with a colliding title.
+    const isSystemAlert = shared.isEngineSystemAlert(item.name, content);
+    const reusable = !isSystemAlert && (category === 'conventions' || hasReusableSignal(content));
     const archiveRelPath = `notes/archive/${dateStamp()}-${item.name}`;
     const kbBody = reusable
       ? content
       : buildCondensedKbBody(content, titleMatch ? titleMatch[0] : null, archiveRelPath);
 
-    const frontmatter = `---\nsource: ${item.name}\nagent: ${agent}\ncategory: ${category}\ndate: ${dateStamp()}\nreusable: ${reusable}\n---\n\n`;
-    try {
-      safeWrite(kbPath, frontmatter + kbBody);
-      classified++;
-    } catch (err) {
-      log('warn', `Failed to classify ${item.name} to knowledge base: ${err.message}`);
+    const alertHash = isSystemAlert ? _alertContentHash(content) : null;
+    if (isSystemAlert && _alertHashExists(categoryDirs[category], alertHash)) {
+      log('info', `KB dedup: skipping recurring engine-alert ${item.name} — duplicate of an existing knowledge/${category} entry`);
+    } else {
+      const frontmatter = `---\nsource: ${item.name}\nagent: ${agent}\ncategory: ${category}\ndate: ${dateStamp()}\nreusable: ${reusable}${isSystemAlert ? `\nalertHash: ${alertHash}` : ''}\n---\n\n`;
+      try {
+        safeWrite(kbPath, frontmatter + kbBody);
+        classified++;
+      } catch (err) {
+        log('warn', `Failed to classify ${item.name} to knowledge base: ${err.message}`);
+      }
     }
 
     // Per-agent memory routing — strict superset of broadcast consolidation.
@@ -1397,4 +1457,6 @@ module.exports = {
   NOTES_MAX_BYTES,
   hasReusableSignal,
   buildCondensedKbBody,
+  _alertContentHash,
+  _alertHashExists,
 };

package/engine/lifecycle.js

@@ -2943,6 +2943,18 @@ function recordPrNoOpFixAttempt(target, cause, source, dispatchItem, branchChang
   return target._noOpFixes[cause];
 }
 
+// #671 — Clears the `_buildFixIneffective` ("infra issue suspected") pause so
+// BUILD_FAILURE auto-fix dispatch can resume. Distinct from
+// `clearPrNoOpFixAttempt` (below) because this pause is headSha-keyed rather
+// than cause-keyed — see `recordBuildFixIneffective` / `shared.isBuildFixIneffectivePaused`.
+// Returns true when a record was actually removed so callers (the dashboard
+// resume endpoint) can distinguish "cleared" from "nothing to clear".
+function clearBuildFixIneffective(target) {
+  if (!target?._buildFixIneffective) return false;
+  delete target._buildFixIneffective;
+  return true;
+}
+
 function clearPrNoOpFixAttempt(target, cause) {
   if (!target?._noOpFixes || !target._noOpFixes[cause]) return;
   delete target._noOpFixes[cause];
@@ -6821,6 +6833,9 @@ module.exports = {
   // Issue #2969 — exported so dashboard.js can clear a paused cause from the
   // resume endpoint.
   clearPrNoOpFixAttempt,
+  // Issue #671 — exported so dashboard.js can clear the build-fix-ineffective
+  // ("infra issue suspected") pause from the resume endpoint.
+  clearBuildFixIneffective,
   // W-mpx44p05000ze8d8 — exported so engine/ado.js + engine/github.js can
   // drop stale `_noOpFixes` records during their PR status poll, and so
   // unit tests can exercise the sweep helper directly.

package/engine/live-checkout.js

@@ -220,6 +220,25 @@ function _collectAutoCleanablePaths(dirtyFiles) {
   return cleanable.length > 0 ? cleanable : null;
 }
 
+// W-mr3lokxs — Cap a porcelain dirty-file list before it is embedded verbatim
+// into a live-checkout-dirty inbox alert body. On GVFS/virtual repos (see the
+// "~120k virtual dirty files" note in prepareLiveCheckout below) a single
+// refusal can report tens of thousands of "modified" paths; embedding the full
+// list produced multi-MB / tens-of-MB alert bodies that then bloated the
+// knowledge base (240 dirty-worktree dumps ≈ 113 MB). Keep the first `maxLines`
+// entries and replace the remainder with a single truncation-notice line so the
+// alert stays human-scannable and bounded. Pure/deterministic — exported for
+// unit testing.
+const DIRTY_ALERT_MAX_LINES = 200;
+function capDirtyFileLines(dirtyFiles, maxLines = DIRTY_ALERT_MAX_LINES) {
+  const lines = Array.isArray(dirtyFiles) ? dirtyFiles : [];
+  const cap = Number.isInteger(maxLines) && maxLines > 0 ? maxLines : DIRTY_ALERT_MAX_LINES;
+  if (lines.length <= cap) return lines.slice();
+  const kept = lines.slice(0, cap);
+  kept.push(`... and ${lines.length - cap} more (run \`git status --porcelain=v1 -b\` locally for the full list)`);
+  return kept;
+}
+
 // issue #608 — detects a branch name that the ENGINE created for a live-mode
 // dispatch (never the operator's own branch). Matches ONLY the literal
 // `work/<wi-id>` convention produced by `shared.deriveWorkItemBranchName` —
@@ -1251,5 +1270,7 @@ module.exports = {
   _looksLikeAgentBranch,
   _extractBranchFromPorcelainHeader,
   _commitAgentWipWithRetry,
+  capDirtyFileLines,
+  DIRTY_ALERT_MAX_LINES,
   LIVE_CHECKOUT_AUTO_CLEAN_PATTERNS,
 };

package/engine/shared.js

@@ -2827,11 +2827,44 @@ const KB_READABLE_CATEGORIES = Object.freeze([
   'consolidated', 'consolidation', 'consolidations',
   'team-memory', 'general', 'patterns',
 ]);
+/**
+ * Detect engine-authored system alerts (dirty-tree refusals, worktree-skip-live
+ * guard notices, blocked/conflicted live-checkout dispatches, managed-spawn
+ * failures, ADO-auth alerts, …). These are operational noise, NOT durable
+ * reusable knowledge, and the same underlying incident recurs verbatim across
+ * many different inbox filenames (one per worktree/date), so consolidation
+ * must never copy their full body into knowledge/ as a distinct "new" entry
+ * per recurrence — see W-mr3pi9de (worktree-skip-live note titles were
+ * identical across every firing regardless of worktree, producing 30+
+ * duplicate-titled knowledge/project-notes/*.md entries on a single day) and
+ * the sibling W-mr3lokxs fix for live-checkout-dirty alerts.
+ *
+ * `engine/dispatch.js#writeInboxAlert` names every file `engine-alert-<slug>-
+ * <date>.md`, so the filename prefix is one signal. `shared.js#_writeWorktree
+ * SkipLiveInboxNote` (and any other engine-authored note) stamps frontmatter
+ * `agent: engine`, accepted as a second signal so alerts written under a
+ * different filename convention are still recognized.
+ */
+function isEngineSystemAlert(name, content) {
+  const nameLower = (name || '').toLowerCase();
+  if (nameLower.includes('engine-alert-') || nameLower.includes('engine-worktree-skip-live-')) return true;
+  const fmMatch = String(content || '').match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (fmMatch && /^agent:\s*engine\s*$/im.test(fmMatch[1])) return true;
+  return false;
+}
+
 /**
  * Classify an inbox item into a knowledge base category.
  * Single source of truth — used by consolidation.js (both LLM and regex paths).
  */
 function classifyInboxItem(name, content) {
+  // W-mr3pi9de / W-mr3lokxs — engine-authored system alerts are operational
+  // noise. Route them to 'project-notes' BEFORE the content-substring
+  // heuristics below, so a note whose body incidentally contains substrings
+  // like 'lint', 'review', or 'pr-' can't be misclassified into
+  // build-reports/reviews. classifyToKnowledgeBase additionally forces these
+  // non-reusable and content-hash-dedups them regardless of category.
+  if (isEngineSystemAlert(name, content)) return 'project-notes';
   const nameLower = (name || '').toLowerCase();
   const contentLower = (content || '').toLowerCase();
   if (nameLower.includes('review') || nameLower.includes('pr-') || nameLower.includes('pr4') || nameLower.includes('feedback')) return 'reviews';
@@ -8893,7 +8926,13 @@ function _writeWorktreeSkipLiveInboxNote(worktreePath, callerTag, blockingInfo)
       `date: ${date}`,
       '---',
       '',
-      `# Engine skipped worktree wipe — live dispatch guard fired (W-mq5rwwss000f30a7)`,
+      // W-mr3pi9de — embed the actual worktree basename, not a hardcoded
+      // literal. The previous fixed string made every note (and therefore
+      // every knowledge/project-notes/*.md entry consolidation wrote from
+      // it) share byte-identical titles regardless of which worktree fired
+      // the guard, defeating uniquePath's -2/-3/… suffixing and flooding the
+      // KB with near-duplicate-content entries under different numbers.
+      `# Engine skipped worktree wipe — live dispatch guard fired (${base})`,
       '',
       `- caller: ${callerTag || 'unknown'}`,
       `- worktree: ${worktreePath}`,
@@ -9434,6 +9473,7 @@ module.exports = {
   KB_CATEGORIES,
   KB_READABLE_CATEGORIES,
   classifyInboxItem,
+  isEngineSystemAlert,
   ENGINE_DEFAULTS,
   resolvePollFlag, // P-c4d8e1a3 — granular per-poller flag resolution
   resolveAgentCli, resolveCcCli, resolveCcUseWorkerPool, resolveAgentModel, resolveCcModel,

package/engine.js

@@ -2583,7 +2583,7 @@ async function spawnAgent(dispatchItem, config) {
         '## Dirty files (`git status --porcelain=v1 -b`)',
         '',
         '```',
-        ...(_dirtyFiles.length > 0 ? _dirtyFiles : ['(none reported)']),
+        ...(_dirtyFiles.length > 0 ? _liveCheckout.capDirtyFileLines(_dirtyFiles) : ['(none reported)']),
         '```',
         '',
         _autoCleanupEnabled

package/package.json

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