@yemi33/minions 0.1.2230 → 0.1.2231

package/dashboard/js/detail-panel.js

@@ -33,6 +33,87 @@ function switchTab(tabId) {
   renderDetailContent(detail, tabId);
 }
 
+// W-mqptc3n3 — Normalize a completion-report `pr` value (canonical id or URL)
+// into the `github:owner/repo#N` / `ado:org/proj/repo#N` form openArtifact
+// expects. Returns null when the value isn't a recognizable PR pointer so the
+// caller can render no chip rather than a broken one.
+function _detailNormalizePrId(value) {
+  if (!value || typeof value !== 'string') return null;
+  var v = value.trim();
+  if (!v || v === 'N/A') return null;
+  if (/^(github|ado):.+#\d+$/i.test(v)) return v;
+  if (typeof _wiDeriveCanonicalPrIdFromUrl === 'function') {
+    var derived = _wiDeriveCanonicalPrIdFromUrl(v);
+    if (derived) return derived;
+  }
+  return null;
+}
+
+// W-mqptc3n3 — Pick the completion report of the most recent SUCCESSFUL
+// (result !== 'error') run for this agent. statusData reflects the latest run
+// inside the 5-min window; when that run is done with an available report it IS
+// the last successful run. Otherwise (idle >5min, latest run errored, or no
+// fresh report) walk recentDispatches (most-recent-first) for the newest
+// non-error run with an available report. Returns null when none qualifies.
+function _lastSuccessfulCompletionReport(detail) {
+  if (!detail || typeof detail !== 'object') return null;
+  var sd = detail.statusData;
+  if (sd && sd.status === 'done' && sd.completionReport && sd.completionReport.available) {
+    return sd.completionReport;
+  }
+  var rds = Array.isArray(detail.recentDispatches) ? detail.recentDispatches : [];
+  for (var i = 0; i < rds.length; i++) {
+    var rd = rds[i];
+    if (rd && rd.result !== 'error' && rd.completionReport && rd.completionReport.available) {
+      return rd.completionReport;
+    }
+  }
+  return null;
+}
+
+// W-mqptc3n3 — Render artifact chips (PR / note / KB) for a successful run's
+// completion report. All chips route through renderArtifactLink (which escapes
+// every field) so click → openArtifact() → modal-stack push comes for free.
+// Returns '' when there is no linkable artifact (no empty header, no broken
+// chip).
+function _renderLastResultArtifactChips(report) {
+  if (!report || typeof report !== 'object') return '';
+  var chips = '';
+  var seen = {};
+  var addPr = function(value, title) {
+    var prId = _detailNormalizePrId(value);
+    if (!prId || seen['pr:' + prId]) return;
+    seen['pr:' + prId] = true;
+    chips += renderArtifactLink({ type: 'pr', id: prId, label: prId, title: title || ('Pull request ' + prId) }) + ' ';
+  };
+  addPr(report.pr, '');
+  var arts = Array.isArray(report.artifacts) ? report.artifacts : [];
+  arts.forEach(function(a) {
+    if (!a || typeof a !== 'object') return;
+    var t = String(a.type || '');
+    var p = String(a.path || '');
+    if (!p) return;
+    if (t === 'pr') {
+      addPr(p, a.title || '');
+    } else if (t === 'note') {
+      var base = p.replace(/^.*[\\/]/, '');
+      if (!base || seen['note:' + base]) return;
+      seen['note:' + base] = true;
+      var noteLabel = base.replace(/\.md$/, '').replace(/^\d{4}-\d{2}-\d{2}-/, '').slice(0, 30) || base;
+      chips += renderArtifactLink({ type: 'note', id: base, label: noteLabel, title: a.title || ('Note: ' + base) }) + ' ';
+    } else if (t === 'kb') {
+      var kbId = p.replace(/^kb:/, '').replace(/^knowledge\//, '');
+      if (!kbId || kbId.indexOf('/') <= 0 || seen['kb:' + kbId]) return;
+      seen['kb:' + kbId] = true;
+      var kbFile = kbId.slice(kbId.indexOf('/') + 1);
+      var kbLabel = kbFile.replace(/\.md$/, '').slice(0, 30) || kbFile;
+      chips += renderArtifactLink({ type: 'kb', id: kbId, label: kbLabel, title: a.title || ('KB: ' + kbFile) }) + ' ';
+    }
+  });
+  if (!chips) return '';
+  return '<div style="display:flex;flex-wrap:wrap;gap:4px;margin-top:8px">' + chips + '</div>';
+}
+
 function renderDetailContent(detail, tab) {
   const el = document.getElementById('detail-content');
 
@@ -72,8 +153,15 @@ function renderDetailContent(detail, tab) {
         if (last.result) html += 'Result: <span style="color:var(--' + (last.result === 'error' ? 'red' : 'green') + ')">' + escHtml(last.result) + '</span>\n';
       }
       html += '</div>';
+      // W-mqptc3n3 — Surface artifact links (PR / note / KB) from the last
+      // SUCCESSFUL run under 'Last Result'. The chips render even when the agent
+      // is idle (>5min, so resultSummary is absent) by sourcing the report from
+      // recentDispatches.
+      var lastResultArtifacts = _renderLastResultArtifactChips(_lastSuccessfulCompletionReport(detail));
       if (detail.statusData.resultSummary) {
-        html += '<h4>Last Result</h4><div class="section" style="border-left:3px solid var(--green);padding-left:12px">' + renderMd(detail.statusData.resultSummary) + '</div>';
+        html += '<h4>Last Result</h4><div class="section" style="border-left:3px solid var(--green);padding-left:12px">' + renderMd(detail.statusData.resultSummary) + lastResultArtifacts + '</div>';
+      } else if (lastResultArtifacts) {
+        html += '<h4>Last Result</h4><div class="section" style="border-left:3px solid var(--green);padding-left:12px">' + lastResultArtifacts + '</div>';
       }
     }
 
@@ -90,7 +178,7 @@ function renderDetailContent(detail, tab) {
       html += '<h4>Latest Output</h4><div class="section">' + renderMd(detail.outputLog) + '</div>';
     }
 
-    // eslint-disable-next-line no-unsanitized/property -- reason: structural HTML is a string literal; all user data wrapped in escHtml()/renderMd() (fields: status task, dispatch task/result/reason, inbox name/content, output log, result summary)
+    // eslint-disable-next-line no-unsanitized/property -- reason: structural HTML is a string literal; all user data wrapped in escHtml()/renderMd()/renderArtifactLink() (fields: status task, dispatch task/result/reason, inbox name/content, output log, result summary, last-result artifact chips (pr/note/kb via renderArtifactLink))
     el.innerHTML = html;
   } else if (tab === 'live') {
     var startedAt = detail.statusData?.started_at;

package/dashboard/js/refresh.js

@@ -131,7 +131,7 @@ function _detectPageChanges(data) {
 // reload path below — RENDER_VERSIONS handles the within-process case.
 const RENDER_VERSIONS = {
   agents: 2,
-  prdProgress: 1,
+  prdProgress: 2,
   prdPrs: 1,
   inbox: 2,
   projects: 3,

package/dashboard/js/render-prd.js

@@ -606,6 +606,10 @@ function renderPrdProgress(prog) {
     if (!e2eByPlan[planKey]) e2eByPlan[planKey] = [];
     e2eByPlan[planKey].push(pr);
   }
+  // W-mqps9jlb — PRD-persisted verify/E2E PR refs (prd.verifyPrs[], surfaced by
+  // queries.getPrdInfo as progress.verifyPrsByPlan). Merged into renderE2eSection
+  // so a merged aggregate PR survives removal of its live tracker record.
+  const persistedVerifyByPlan = (prog && prog.verifyPrsByPlan) || {};
 
   // Find testing guides in prd/ (verify-*.md files). Issue #2949 —
   // verifyGuides moved off /api/status to /api/verify-guides; refresh.js
@@ -618,13 +622,24 @@ function renderPrdProgress(prog) {
   }
 
   function renderE2eSection(planFile) {
-    // Keep abandoned/closed E2E PRs visible (rendered de-emphasized via the
-    // muted status badge) so a closed verify PR still shows on its PRD as
-    // closed rather than silently vanishing. Sort terminal-abandoned ones last
-    // so live/merged aggregates stay on top.
-    const prs = (e2eByPlan[planFile] || [])
-      .slice()
-      .sort((a, b) => (a.status === 'abandoned' ? 1 : 0) - (b.status === 'abandoned' ? 1 : 0));
+    // Merge the LIVE tracker E2E PRs (e2eByPlan[planFile]) with the PRD-persisted
+    // verify PR refs (persistedVerifyByPlan[planFile], stamped onto prd.verifyPrs
+    // by lifecycle.persistVerifyPrsToPrd). Dedup by pr.id with the LIVE record
+    // winning, so a merged aggregate PR keeps rendering on its PRD even after its
+    // live tracker record has been swept (e.g. daily-remove-merged-prs) — W-mqps9jlb.
+    const livePrs = e2eByPlan[planFile] || [];
+    const persistedPrs = persistedVerifyByPlan[planFile] || [];
+    const mergedById = new Map();
+    for (const p of persistedPrs) { if (p && p.id != null) mergedById.set(p.id, { ...p, _project: p.project || p._project || '' }); }
+    const liveNoId = [];
+    for (const p of livePrs) { if (p && p.id != null) { mergedById.set(p.id, p); } else if (p) { liveNoId.push(p); } }
+    // Keep abandoned/closed/merged E2E PRs visible (rendered de-emphasized via a
+    // muted status badge + reduced opacity) so a terminal verify PR still shows on
+    // its PRD rather than silently vanishing. Sort terminal rows after active ones;
+    // abandoned last of all.
+    const termRank = (s) => (s === 'abandoned' ? 2 : (s && s !== 'active' ? 1 : 0));
+    const prs = [...mergedById.values(), ...liveNoId]
+      .sort((a, b) => (termRank(a.status) - termRank(b.status)) || ((a.status === 'abandoned' ? 1 : 0) - (b.status === 'abandoned' ? 1 : 0)));
     const guide = guideByPlan[planFile];
     if (prs.length === 0 && !guide) return '';
     let html = '<div style="margin:6px 0 10px;padding:6px 10px;background:rgba(56,139,253,0.08);border:1px solid rgba(56,139,253,0.25);border-radius:4px">';
@@ -632,11 +647,13 @@ function renderPrdProgress(prog) {
       html += '<div style="font-size:var(--text-sm);font-weight:600;color:var(--blue);margin-bottom:4px">E2E Aggregate PRs</div>';
       html += prs.map(pr => {
         const statusColor = _prStatusColor(pr.status);
+        // Terminal (non-active) aggregates render de-emphasized like the abandoned case.
+        const rowOpacity = (pr.status && pr.status !== 'active') ? '0.65' : '1';
         // P-79b47b0c — render PR id as in-stack chip (was raw <a target="_blank">).
         const prChip = (typeof renderArtifactLink === 'function')
           ? renderArtifactLink({ type: 'pr', id: pr.id, label: pr.id, title: pr.title || pr.id })
           : '<code>' + escHtml(pr.id) + '</code>';
-        return '<div style="display:flex;align-items:center;gap:6px;padding:2px 0;font-size:var(--text-base)">' +
+        return '<div style="display:flex;align-items:center;gap:6px;padding:2px 0;font-size:var(--text-base);opacity:' + rowOpacity + '">' +
           '<span style="color:' + statusColor + ';font-size:var(--text-xs);font-weight:600;padding:1px 4px;border:1px solid;border-radius:3px">' + escHtml(pr.status || 'active') + '</span>' +
           prChip +
           '<span style="color:var(--text);flex:1;overflow:hidden;text-overflow:ellipsis;white-space:nowrap">' + escHtml(pr.title || '') + '</span>' +

package/engine/lifecycle.js

@@ -5557,6 +5557,123 @@ function syncPrdFromPrs(config) {
   }
 }
 
+// ─── Persist verify/E2E aggregate PRs onto the PRD JSON (W-mqps9jlb) ──────────
+// The PRD view's "E2E Aggregate PRs" section (dashboard/js/render-prd.js#
+// renderE2eSection) sources its PRs from the LIVE tracker (pull-requests.json).
+// A merged aggregate PR therefore VANISHES from the PRD page once its record is
+// swept — by the daily-remove-merged-prs schedule, a manual delete, or a
+// merge-back/reconcile flow. To make the PRD view survive removal of the live
+// record we durably stamp a compact reference array (`prd.verifyPrs`) onto the
+// owning PRD JSON.
+//
+// This runs per-tick (right after syncPrdFromPrs). It reads the NORMALIZED
+// pull-requests.json schema, so a single sweep covers BOTH the GitHub and ADO
+// pollers at once (engine/github.js + engine/ado.js are intentional mirrors
+// writing the same schema) — the durable single-source approach the task
+// allows in lieu of hooking each poller's merged transition separately. Because
+// it re-stamps every tick, the persisted copy is KEPT CURRENT through the
+// merged transition: the last poll before the sweep records status:'merged' +
+// mergedAt. Append-only-ish — a previously-recorded verify PR is never dropped
+// just because it left the live tracker.
+
+/** Match the dashboard's renderE2eSection predicate (render-prd.js ~line 603). */
+function _isVerifyAggregatePr(pr) {
+  if (!pr || typeof pr !== 'object') return false;
+  // Literal 'verify'/'pr' itemType strings to mirror render-prd.js exactly —
+  // note there is no WORK_TYPE.PR constant; the PR aggregate itemType is 'pr'.
+  return pr.itemType === WORK_TYPE.VERIFY
+    || pr.itemType === 'pr'
+    || pr.e2e === true
+    || (typeof pr.title === 'string' && pr.title.startsWith('[E2E]'));
+}
+
+/** Compact, render-ready reference persisted onto prd.verifyPrs[]. */
+function _verifyPrRef(pr, projectName) {
+  const ref = {
+    id: pr.id,
+    url: pr.url || '',
+    title: pr.title || '',
+    status: pr.status || PR_STATUS.ACTIVE,
+    project: pr._project || projectName || '',
+  };
+  if (pr.mergedAt) ref.mergedAt = pr.mergedAt;
+  return ref;
+}
+
+/** True when persisting `refMap` would change the existing prd.verifyPrs[]. */
+function _verifyPrsNeedUpdate(existing, refMap) {
+  const byId = new Map();
+  for (const e of (existing || [])) { if (e && e.id) byId.set(e.id, e); }
+  for (const [id, ref] of refMap) {
+    const cur = byId.get(id);
+    if (!cur) return true;
+    if ((cur.status || '') !== (ref.status || '')) return true;
+    if ((cur.url || '') !== (ref.url || '')) return true;
+    if ((cur.title || '') !== (ref.title || '')) return true;
+    if ((cur.project || '') !== (ref.project || '')) return true;
+    if ((cur.mergedAt || '') !== (ref.mergedAt || '')) return true;
+  }
+  return false;
+}
+
+function persistVerifyPrsToPrd(config) {
+  try {
+    config = config || queries.getConfig();
+    if (!fs.existsSync(PRD_DIR)) return;
+    const projects = shared.getProjects(config);
+    if (!projects.length) return;
+
+    // Group verify/E2E PR refs by sourcePlan (PRD filename) across all projects.
+    const refsByPlan = new Map(); // planFile -> Map(id -> ref)
+    for (const project of projects) {
+      let prs;
+      try { prs = safeJsonArr(shared.projectPrPath(project)); } catch { continue; }
+      for (const pr of (prs || [])) {
+        if (!pr || !pr.id) continue;
+        if (!_isVerifyAggregatePr(pr)) continue;
+        const planFile = typeof pr.sourcePlan === 'string' ? pr.sourcePlan.trim() : '';
+        if (!planFile) continue; // can't attribute to a PRD without a sourcePlan
+        if (!refsByPlan.has(planFile)) refsByPlan.set(planFile, new Map());
+        // A canonical PR id is unique to one project, so last-writer-wins here
+        // only ever collapses byte-identical duplicates within a tick.
+        refsByPlan.get(planFile).set(pr.id, _verifyPrRef(pr, project.name));
+      }
+    }
+    if (refsByPlan.size === 0) return;
+
+    for (const [planFile, refMap] of refsByPlan) {
+      // Resolve the PRD file (active or archived). sourcePlan is a bare filename.
+      const candidates = [path.join(PRD_DIR, planFile), path.join(PRD_DIR, 'archive', planFile)];
+      const fpath = candidates.find(p => { try { return fs.existsSync(p); } catch { return false; } });
+      if (!fpath) continue;
+
+      // Lock-free peek (mirrors syncPrdItemStatus): only take the write lock
+      // when the persisted refs would actually change. safeJsonNoRestore so an
+      // archived PRD's .backup sidecar can't resurrect stale state.
+      let plan;
+      try { plan = safeJsonNoRestore(fpath); } catch { continue; }
+      if (!plan || typeof plan !== 'object') continue;
+      if (!_verifyPrsNeedUpdate(plan.verifyPrs, refMap)) continue;
+
+      mutateJsonFileLocked(fpath, (fresh) => {
+        if (!fresh || typeof fresh !== 'object') return fresh;
+        const byId = new Map();
+        for (const e of (Array.isArray(fresh.verifyPrs) ? fresh.verifyPrs : [])) {
+          if (e && e.id) byId.set(e.id, e);
+        }
+        // Upsert live refs (kept current); never drop a previously-recorded one.
+        for (const [id, ref] of refMap) {
+          byId.set(id, { ...(byId.get(id) || {}), ...ref });
+        }
+        fresh.verifyPrs = [...byId.values()];
+        return fresh;
+      }, { skipWriteIfUnchanged: true });
+    }
+  } catch (err) {
+    try { log('warn', `persistVerifyPrsToPrd error: ${err?.message || err}`); } catch { /* engine not available */ }
+  }
+}
+
 // ─── Failure Classification ─────────────────────────────────────────────────
 
 /**
@@ -5794,6 +5911,7 @@ module.exports = {
   promoteCompletionArtifacts,
   runPostCompletionHooks,
   syncPrdFromPrs,
+  persistVerifyPrsToPrd,
   resolveWorkItemPath,
   isItemCompleted,
   classifyFailure,

package/engine/queries.js

@@ -1971,6 +1971,11 @@ function getPrdInfo(config) {
 
   let allPrdItems = [];
   const existingPrds = [];
+  // W-mqps9jlb — verify/E2E aggregate PR refs persisted onto each PRD JSON
+  // (prd.verifyPrs[], stamped by lifecycle.persistVerifyPrsToPrd). Keyed by PRD
+  // filename so render-prd.js#renderE2eSection can merge them with the live
+  // tracker and keep rendering a merged aggregate after its live record is swept.
+  const verifyPrsByPlan = {};
   let latestStat = null;
 
   // Check if directory listings need refresh
@@ -2019,6 +2024,13 @@ function getPrdInfo(config) {
             completedAt: plan.completedAt || '',
             _archived: archived,
           });
+          if (Array.isArray(plan.verifyPrs) && plan.verifyPrs.length > 0) {
+            verifyPrsByPlan[pf] = plan.verifyPrs.map(r => ({
+              id: r.id, url: r.url || '', title: r.title || '',
+              status: r.status || 'active', project: r.project || '',
+              ...(r.mergedAt ? { mergedAt: r.mergedAt } : {}),
+            }));
+          }
           for (const f of plan.missing_features) {
             allPrdItems.push({
               ...f, _source: pf, _planStatus: plan.status || 'active',
@@ -2205,6 +2217,7 @@ function getPrdInfo(config) {
 
   const progress = {
     total, complete, inProgress, paused, missing, donePercent, planTimings,
+    verifyPrsByPlan,
     items: items.map(i => ({
       id: i.id, name: i.name || i.title, priority: i.priority,
       complexity: i.estimated_complexity || i.size, status: i.status || 'missing',

package/engine.js

@@ -166,7 +166,7 @@ const ghToken = require('./engine/gh-token');
 
 const { runPostCompletionHooks, updateWorkItemStatus, syncPrdItemStatus, reconcilePrdStatuses, handlePostMerge, checkPlanCompletion,
   syncPrsFromOutput, updatePrAfterReview, updatePrAfterFix, checkForLearnings, extractSkillsFromOutput,
-  updateAgentHistory, updateMetrics, createReviewFeedbackForAuthor, parseAgentOutput, syncPrdFromPrs,
+  updateAgentHistory, updateMetrics, createReviewFeedbackForAuthor, parseAgentOutput, syncPrdFromPrs, persistVerifyPrsToPrd,
   isItemCompleted, classifyFailure: classifyFailureFallback, diagnoseEmptyOutput, processPendingRebases, resolveWorkItemPath,
   mergeArtifactNotes, promoteCompletionArtifacts, pruneScopeMismatchDuplicatePrs } = require('./engine/lifecycle');
 
@@ -9281,6 +9281,7 @@ async function tickInner() {
     if (_isTickStale(myGeneration)) return;
     // Sync PR status back to PRD items (missing → done when active PR exists)
     try { syncPrdFromPrs(config); } catch (err) { log('warn', `PRD sync error: ${err?.message || err}`); }
+    try { persistVerifyPrsToPrd(config); } catch (err) { log('warn', `PRD verify-PR persist error: ${err?.message || err}`); }
     // Check if any plans can be marked completed (all features done/in-pr)
     try {
       const prdFiles = safeReadDir(PRD_DIR).filter(f => f.endsWith('.json'));

package/package.json

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