@yemi33/minions 0.1.1552 → 0.1.1554

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.1.1554 (2026-04-27)
+
+### Fixes
+- archive bugs — undefined resetBtn, .backup re-trigger, dispatch leak
+
+## 0.1.1553 (2026-04-27)
+
+### Other
+- refactor(queries): cache PR list, fold ghost-project scan into single readdir pass
+
 ## 0.1.1552 (2026-04-27)
 
 ### Fixes

package/dashboard/js/render-plans.js

@@ -601,13 +601,12 @@ async function planArchive(file, btn) {
   if (!confirm(confirmMsg)) return;
   _stopPlanPoll();
   markDeleted('plan:' + file);
-  // Also optimistically hide the linked source plan (server archives both)
   if (isPrd) {
     var linkedPlan = (window._lastPlans || []).find(function(p) { return p.file === file && p.sourcePlan; });
     if (linkedPlan) markDeleted('plan:' + linkedPlan.sourcePlan);
   }
   try { closeModal(); } catch { /* may not be open */ }
-  showToast('cmd-toast', 'Archiving...', true);
+  showToast('cmd-toast', 'Archived', true);
   try {
     const res = await fetch('/api/plans/archive', {
       method: 'POST', headers: { 'Content-Type': 'application/json' },
@@ -617,16 +616,18 @@ async function planArchive(file, btn) {
     if (!ct.includes('json')) { refresh(); return; }
     const d = await res.json().catch(() => ({}));
     if (res.ok && d.ok) {
-      var msg = 'Archived';
-      if (d.archivedSource) msg += ' PRD + source plan (' + d.archivedSource + ')';
-      if (d.cancelledItems) msg += ', cancelled ' + d.cancelledItems + ' pending item(s)';
-      showToast('cmd-toast', msg, true);
+      if (d.archivedSource || d.cancelledItems) {
+        var msg = 'Archived';
+        if (d.archivedSource) msg += ' PRD + source plan';
+        if (d.cancelledItems) msg += ', cancelled ' + d.cancelledItems + ' pending item(s)';
+        showToast('cmd-toast', msg, true);
+      }
       refresh();
     } else {
-      resetBtn();
-      alert('Archive failed: ' + (d.error || 'unknown'));
+      showToast('cmd-toast', 'Archive failed: ' + (d.error || 'unknown'), false);
+      refresh();
     }
-  } catch (e) { resetBtn(); alert('Error: ' + e.message); }
+  } catch (e) { showToast('cmd-toast', 'Error: ' + e.message, false); refresh(); }
 }
 
 async function planPause(file, btn) {
@@ -793,8 +794,12 @@ async function planUnarchive(file, btn) {
       body: JSON.stringify({ file })
     });
     if (res.ok) { refreshPlans(); refresh(); }
-    else { const d = await res.json().catch(() => ({})); alert('Unarchive failed: ' + (d.error || 'unknown')); refresh(); }
-  } catch (e) { alert('Error: ' + e.message); refresh(); }
+    else {
+      const d = await res.json().catch(() => ({}));
+      showToast('cmd-toast', 'Unarchive failed: ' + (d.error || 'unknown'), false);
+      refresh();
+    }
+  } catch (e) { showToast('cmd-toast', 'Error: ' + e.message, false); refresh(); }
 }
 
 window.MinionsPlans = { openCreatePlanModal, refreshPlans, derivePlanStatus, renderPlans, openArchivedPlansModal, planExecute, planSubmitRevise, planShowRevise, planHideRevise, planView, planApprove, planArchive, planUnarchive, planDelete, planPause, planReject, planDiscuss, planOpenInDocChat, planRegeneratePRD, openVerifyGuide, triggerVerify };

package/dashboard.js

@@ -3341,46 +3341,69 @@ If nothing to do: { "duplicates": [], "reclassify": [], "remove": [] }`;
     try {
       const body = await readBody(req);
       if (!body.file) return jsonReply(res, 400, { error: 'file required' });
-      shared.sanitizePath(body.file, body.file.endsWith('.json') ? PRD_DIR : PLANS_DIR);
+      const isPrd = body.file.endsWith('.json');
+      shared.sanitizePath(body.file, isPrd ? PRD_DIR : PLANS_DIR);
       const planPath = resolvePlanPath(body.file);
       if (!fs.existsSync(planPath)) return jsonReply(res, 404, { error: 'plan not found' });
 
-      // Move to archive directory
-      const archiveDir = body.file.endsWith('.json') ? path.join(PRD_DIR, 'archive') : path.join(PLANS_DIR, 'archive');
+      const archiveDir = isPrd ? path.join(PRD_DIR, 'archive') : path.join(PLANS_DIR, 'archive');
       if (!fs.existsSync(archiveDir)) fs.mkdirSync(archiveDir, { recursive: true });
       const archivePath = path.join(archiveDir, body.file);
       fs.renameSync(planPath, archivePath);
 
-      // Mark archived in JSON if PRD
       let archivedSource = null;
-      if (body.file.endsWith('.json')) {
+      let plan = {};
+      if (isPrd) {
         try {
-          const prd = safeJsonObj(archivePath);
-          prd.status = 'archived';
-          prd.archivedAt = new Date().toISOString();
-          safeWrite(archivePath, prd);
-          // Also archive linked source plan
-          if (prd.source_plan) {
-            const mdPath = path.join(PLANS_DIR, prd.source_plan);
+          plan = safeJsonObj(archivePath) || {};
+          plan.status = 'archived';
+          plan.archivedAt = new Date().toISOString();
+          safeWrite(archivePath, plan);
+          // Without removing the .backup sidecar, safeJson would auto-restore the
+          // pre-completion snapshot on engine restart, re-triggering plan completion
+          // and spawning duplicate verify tasks (regression of #f28162b0).
+          const backupPath = planPath + '.backup';
+          try { fs.unlinkSync(backupPath); } catch {
+            try { fs.writeFileSync(backupPath, JSON.stringify({ status: 'archived' })); } catch { /* best-effort */ }
+          }
+          if (plan.source_plan) {
+            const mdPath = path.join(PLANS_DIR, plan.source_plan);
             if (fs.existsSync(mdPath)) {
               const planArchive = path.join(PLANS_DIR, 'archive');
               if (!fs.existsSync(planArchive)) fs.mkdirSync(planArchive, { recursive: true });
-              fs.renameSync(mdPath, path.join(planArchive, prd.source_plan));
-              archivedSource = prd.source_plan;
+              fs.renameSync(mdPath, path.join(planArchive, plan.source_plan));
+              archivedSource = plan.source_plan;
             }
           }
         } catch { /* optional */ }
       }
 
-      // Clean up worktrees associated with this plan
+      // Cancel pending work items linked to this plan so the engine stops
+      // dispatching for an archived plan. Done items are preserved as history.
+      let cancelledItems = 0;
+      const wiPaths = [path.join(MINIONS_DIR, 'work-items.json'), ...PROJECTS.map(p => shared.projectWorkItemsPath(p))];
+      for (const wiPath of wiPaths) {
+        try {
+          mutateWorkItems(wiPath, items => {
+            for (const w of items) {
+              if (w.sourcePlan !== body.file) continue;
+              if (w.status === WI_STATUS.PENDING || w.status === WI_STATUS.QUEUED) {
+                w.status = WI_STATUS.CANCELLED;
+                w._cancelledBy = 'plan-archived';
+                cancelledItems++;
+              }
+            }
+          });
+        } catch (e) { console.error('plan archive cancel:', e.message); }
+      }
+
       try {
-        const plan = body.file.endsWith('.json') ? (safeJsonObj(archivePath) || {}) : {};
         const { cleanupPlanWorktrees } = require('./engine/lifecycle');
         cleanupPlanWorktrees(body.file, plan, PROJECTS, getConfig());
       } catch (e) { console.error('plan worktree cleanup:', e.message); }
 
       invalidateStatusCache();
-      return jsonReply(res, 200, { ok: true, archived: body.file, archivedSource });
+      return jsonReply(res, 200, { ok: true, archived: body.file, archivedSource, cancelledItems });
     } catch (e) { return jsonReply(res, 400, { error: e.message }); }
   }
 

package/engine/pipeline.js

@@ -231,8 +231,9 @@ function evaluateCondition(condition, ctx) {
       return pipelineRuns.length >= threshold;
     }
     case 'allBuildsGreen': {
-      // True when all PRs in monitoredResources (pipeline-level or stage-level) or run artifacts have buildStatus 'passing'
-      const allPrs = queries.getPullRequests(config);
+      // True when all PRs in monitoredResources (pipeline-level or stage-level) or run artifacts have buildStatus 'passing'.
+      // Exclude ghost PRs (records from project subdirs not in config) — their buildStatus is stale because no poller updates them.
+      const allPrs = queries.getPullRequests(config).filter(pr => !pr._ghost);
       const prRefs = collectPipelinePrRefs(pipeline, run);
       if (prRefs.length === 0) return false; // no PRs to check = can't confirm green
       for (const prRef of prRefs) {

package/engine/queries.js

@@ -11,7 +11,7 @@ const shared = require('./shared');
 
 const { safeRead, safeReadDir, safeJson, safeWrite, getProjects, mutateJsonFileLocked,
   projectWorkItemsPath, projectPrPath, parseSkillFrontmatter, KB_CATEGORIES,
-  WI_STATUS, DONE_STATUSES, PRD_ITEM_STATUS, ENGINE_DEFAULTS } = shared;
+  WI_STATUS, DONE_STATUSES, PRD_ITEM_STATUS, PR_STATUS, ENGINE_DEFAULTS } = shared;
 
 /**
  * Read the first `bytes` and last `bytes` of a file efficiently using byte offsets.
@@ -472,34 +472,57 @@ function getPrs(project) {
   return all;
 }
 
+// Cache: getPullRequests is called 3-5x per /api/status (getMetrics, getWorkItems,
+// getPrdInfo, dashboard.js status + count). 1s TTL eliminates redundant fs reads
+// within a single request without masking real updates from polling.
+let _prsCache = null;
+let _prsCacheAt = 0;
+
 function getPullRequests(config) {
+  const now = Date.now();
+  if (_prsCache && (now - _prsCacheAt) < 1000) return _prsCache;
   config = config || getConfig();
   const projects = getProjects(config);
+  const projectByName = new Map(projects.map(p => [p.name, p]));
   const allPrs = [];
-  for (const project of projects) {
-    const prs = safeJson(projectPrPath(project));
-    if (!prs) continue;
+  const seenIds = new Set();
+  // Single pass over projects/* — configured projects use their full config
+  // (prUrlBase fill-in, _project name); unconfigured subdirs are tagged _ghost
+  // so engine code can filter them out. Mirrors what shared.getPrLinks scans,
+  // so PRD links and PR records stay in sync after a project is removed.
+  let projectDirs = [];
+  try {
+    projectDirs = fs.readdirSync(path.join(MINIONS_DIR, 'projects'), { withFileTypes: true })
+      .filter(d => d.isDirectory()).map(d => d.name);
+  } catch { /* projects dir missing */ }
+  for (const dirName of projectDirs) {
+    const project = projectByName.get(dirName) || null;
+    const prPath = project ? projectPrPath(project) : path.join(MINIONS_DIR, 'projects', dirName, 'pull-requests.json');
+    const prs = safeJson(prPath);
+    if (!Array.isArray(prs)) continue;
     shared.normalizePrRecords(prs, project);
-    const base = project.prUrlBase || '';
+    const base = project?.prUrlBase || '';
     for (const pr of prs) {
-      if (!pr.url && base) {
+      if (!pr?.id || seenIds.has(pr.id)) continue;
+      if (project && !pr.url && base) {
         const prNumber = shared.getPrNumber(pr);
         if (prNumber != null) pr.url = base + prNumber;
       }
-      pr._project = project.name || 'Project';
+      pr._project = project ? (project.name || 'Project') : dirName;
+      if (!project) pr._ghost = true;
       allPrs.push(pr);
+      seenIds.add(pr.id);
     }
   }
-  // Also read central pull-requests.json (for manually linked PRs without a project)
-  const centralPath = path.join(MINIONS_DIR, 'pull-requests.json');
-  const centralPrs = safeJson(centralPath);
+  // Central pull-requests.json — manually linked PRs without a project
+  const centralPrs = safeJson(path.join(MINIONS_DIR, 'pull-requests.json'));
   if (centralPrs) {
     shared.normalizePrRecords(centralPrs, null);
     for (const pr of centralPrs) {
-      if (!allPrs.some(p => p.id === pr.id)) {
-        pr._project = 'central';
-        allPrs.push(pr);
-      }
+      if (!pr?.id || seenIds.has(pr.id)) continue;
+      pr._project = 'central';
+      allPrs.push(pr);
+      seenIds.add(pr.id);
     }
   }
   allPrs.sort((a, b) => {
@@ -513,9 +536,35 @@ function getPullRequests(config) {
     const bNum = parseInt((b.id || '').replace(/\D/g, '')) || 0;
     return bNum - aNum;
   });
+  _prsCache = allPrs;
+  _prsCacheAt = now;
   return allPrs;
 }
 
+// Resolve a PR URL by preferring the canonical PR ID's own scope (e.g.
+// `github:owner/repo#N`) so a github PR never gets an ADO URL just because the
+// only configured project happens to be ADO. Falls back to a name-matched
+// project's prUrlBase only when the ID is legacy (`PR-N`) and a real project
+// owns it. Never blindly uses projects[0].
+function buildPrUrlFromId(prId, pr, projects) {
+  if (pr?.url) return pr.url;
+  const canonical = shared.parseCanonicalPrId(prId);
+  if (canonical) {
+    const [host, rest] = canonical.scope.split(':');
+    if (host === 'github') return `https://github.com/${rest}/pull/${canonical.prNumber}`;
+    if (host === 'ado') {
+      const [org, adoProject, repo] = rest.split('/');
+      if (org && adoProject && repo) {
+        return `https://dev.azure.com/${org}/${adoProject}/_git/${repo}/pullrequest/${canonical.prNumber}`;
+      }
+    }
+  }
+  const project = pr?._project ? projects.find(p => p.name === pr._project) : null;
+  const prNumber = shared.getPrNumber(pr || prId);
+  if (project?.prUrlBase && prNumber != null) return project.prUrlBase + prNumber;
+  return '';
+}
+
 // ── Skills ──────────────────────────────────────────────────────────────────
 
 function collectSkillFiles(config) {
@@ -1017,56 +1066,12 @@ function getPrdInfo(config) {
     for (const wi of centralWi) { if (!wi?.id) { console.warn('[queries] Skipping central work item without id:', JSON.stringify(wi).slice(0, 120)); continue; } if (wi.sourcePlan && !wiById[wi.id]) wiById[wi.id] = wi; }
   } catch { /* optional */ }
 
-  // PR-to-PRD linking — derived from PR.prdItems (single source of truth)
+  // PR-to-PRD linking — derived from PR.prdItems (single source of truth).
+  // getPullRequests includes records from unconfigured project subdirs so PRD
+  // links can resolve to last-known status even after a project is removed.
   const allPrs = getPullRequests(config);
   const prById = {};
   for (const pr of allPrs) prById[pr.id] = pr;
-  // Also scan project subdirectories that aren't in config (e.g. removed projects
-  // whose pull-requests.json still holds last-known status). getPrLinks already
-  // reads all subdirs, so without this PRs from those dirs would have status/title
-  // missing in the PRD view and fall back to literal 'active'/'' defaults.
-  try {
-    const projectsDir = path.join(MINIONS_DIR, 'projects');
-    const projectsByName = new Map(projects.map(p => [p.name, p]));
-    for (const d of fs.readdirSync(projectsDir, { withFileTypes: true })) {
-      if (!d.isDirectory() || projectsByName.has(d.name)) continue;
-      const ghostPath = path.join(projectsDir, d.name, 'pull-requests.json');
-      const ghostPrs = safeJson(ghostPath);
-      if (!Array.isArray(ghostPrs)) continue;
-      shared.normalizePrRecords(ghostPrs, null);
-      for (const pr of ghostPrs) {
-        if (pr?.id && !prById[pr.id]) {
-          pr._project = d.name;
-          prById[pr.id] = pr;
-        }
-      }
-    }
-  } catch { /* projects dir missing */ }
-
-  // Build URL for a PR when pr.url isn't set. Prefer the PR ID's own scope
-  // (e.g. `github:owner/repo#123` → github.com URL) so a github PR never gets
-  // an ADO URL just because the only configured project happens to be ADO.
-  // Only use a project's prUrlBase when its host actually matches the PR.
-  const _buildPrUrlFromId = (prId, pr) => {
-    if (pr?.url) return pr.url;
-    const canonical = shared.parseCanonicalPrId(prId);
-    if (canonical) {
-      const [host, rest] = canonical.scope.split(':');
-      if (host === 'github') return `https://github.com/${rest}/pull/${canonical.prNumber}`;
-      if (host === 'ado') {
-        const [org, adoProject, repo] = rest.split('/');
-        if (org && adoProject && repo) {
-          return `https://dev.azure.com/${org}/${adoProject}/_git/${repo}/pullrequest/${canonical.prNumber}`;
-        }
-      }
-    }
-    // Legacy `PR-N` ID with no host scope: only use project's prUrlBase if a
-    // matching project (by name) exists. Never blindly fall back to projects[0].
-    const project = pr?._project ? projects.find(p => p.name === pr._project) : null;
-    const prNumber = shared.getPrNumber(pr || prId);
-    if (project?.prUrlBase && prNumber != null) return project.prUrlBase + prNumber;
-    return '';
-  };
 
   const prdToPr = {};
   const prLinks = shared.getPrLinks(); // { "PR-xxxx": ["P-xxxx", "P-yyyy"] }
@@ -1076,10 +1081,10 @@ function getPrdInfo(config) {
     // (or are typed as verify) and would bleed through as duplicate entries on every
     // constituent item. They are surfaced via renderE2eSection instead. (#1220)
     if ((itemIds || []).length > 1 || pr?.itemType === 'verify' || pr?.title?.startsWith('[E2E]')) continue;
-    const url = _buildPrUrlFromId(prId, pr);
+    const url = buildPrUrlFromId(prId, pr, projects);
     for (const itemId of (itemIds || [])) {
       if (!prdToPr[itemId]) prdToPr[itemId] = [];
-      prdToPr[itemId].push({ id: prId, url, title: pr?.title || '', status: pr?.status || 'active', _project: pr?._project || '' });
+      prdToPr[itemId].push({ id: prId, url, title: pr?.title || '', status: pr?.status || PR_STATUS.ACTIVE, _project: pr?._project || '' });
     }
   }
   // Fallback: work item _pr field for anything still missing
@@ -1090,21 +1095,20 @@ function getPrdInfo(config) {
     const exactPr = prById[canonicalPrId] || null;
     const displayMatches = exactPr ? [] : Object.values(prById).filter(candidate => shared.getPrDisplayId(candidate) === shared.getPrDisplayId(wi._pr));
     const pr = exactPr || (displayMatches.length === 1 ? displayMatches[0] : null);
-    const url = _buildPrUrlFromId(canonicalPrId || wi._pr, pr);
-    prdToPr[wi.id] = [{ id: pr?.id || canonicalPrId || wi._pr, url, title: pr?.title || '', status: pr?.status || 'active', _project: project?.name || '' }];
+    const url = buildPrUrlFromId(canonicalPrId || wi._pr, pr, projects);
+    prdToPr[wi.id] = [{ id: pr?.id || canonicalPrId || wi._pr, url, title: pr?.title || '', status: pr?.status || PR_STATUS.ACTIVE, _project: project?.name || '' }];
   }
   // Aggregate sub-task PRs to decomposed parent (sub-tasks aren't PRD items but their PRs should show)
   for (const pr of allPrs) {
     for (const itemId of (pr.prdItems || [])) {
-      // Find if this is a sub-task with a parent
       const allItems = Object.values(wiById);
       const wi = allItems.find(w => w.id === itemId && w.parent_id);
       if (!wi) continue;
       const parentId = wi.parent_id;
       if (!prdToPr[parentId]) prdToPr[parentId] = [];
       if (!prdToPr[parentId].some(p => p.id === pr.id)) {
-        const url = _buildPrUrlFromId(pr.id, pr);
-        prdToPr[parentId].push({ id: pr.id, url, title: pr.title || '', status: pr.status || 'active', _project: pr._project || '' });
+        const url = buildPrUrlFromId(pr.id, pr, projects);
+        prdToPr[parentId].push({ id: pr.id, url, title: pr.title || '', status: pr.status || PR_STATUS.ACTIVE, _project: pr._project || '' });
       }
     }
   }

package/package.json

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