@yemi33/minions 0.1.2274 → 0.1.2276

package/dashboard.js

@@ -8260,6 +8260,21 @@ const server = http.createServer(async (req, res) => {
         cleanupPlanWorktrees(body.file, planObj || {}, PROJECTS, getConfig());
       } catch (e) { console.error('plan worktree cleanup:', e.message); }
       safeUnlink(planPath);
+      // Neutralize the `.backup` sidecar so `safeJson` auto-restore can't
+      // RESURRECT the PRD we just deleted (the live file is gone, but a stray
+      // `prd/<plan>.json.backup` would be auto-restored on the next safeJson read
+      // — the PRD comes back, with its prior `status: approved/active`, and the
+      // materializer re-dispatches its work items). Mirrors the Archive handler's
+      // backup cleanup (handlePlansArchive). A PRD delete must remove the restore
+      // fuel, not just the live file.
+      if (body.file.endsWith('.json')) {
+        try {
+          const backupCleanup = shared.neutralizeJsonBackupSidecar(planPath);
+          if (!backupCleanup.ok) {
+            console.warn(`Delete backup cleanup failed for ${body.file}: unlink (${backupCleanup.unlinkError}) / neutralize (${backupCleanup.writeError})`);
+          }
+        } catch (e) { console.warn(`Delete backup cleanup threw for ${body.file}: ${e.message}`); }
+      }
 
       // Clean up materialized work items from all projects + central
       let cleaned = 0;

package/engine/queries.js

@@ -1977,6 +1977,18 @@ function getWorkItems(config, opts) {
   // Use snapshot — sync access; cold start before any async warm returns [].
   // Best-effort enrichment for work item _artifacts.notes, not correctness-critical.
   const _kbEntries = getKnowledgeBaseEntriesSnapshot();
+  // PERF (dashboard event-loop freeze fix): the notes-linkage match below is
+  // `entry contains agentId AND entry contains itemId`. Filtering the FULL
+  // _kbEntries (can be ~10k) and _archiveFiles (~2k) per work item is O(items ×
+  // files) — on a busy instance that's millions of String.includes() per
+  // /api/work-items call, run synchronously, which hard-freezes the single
+  // dashboard event loop. Bucket the two large collections by agentId ONCE per
+  // distinct agent (lazily, like _agentDirCache above), then each item only
+  // scans its agent's much-smaller bucket for the itemId. Exact same match
+  // semantics; O(agents × files) one-time + O(items × bucket) instead of
+  // O(items × files). _inboxFiles stays a direct filter (tiny — a handful).
+  const _kbByAgent = {};      // agentId → kb entries whose source includes agentId
+  const _archiveByAgent = {}; // agentId → archive filenames that include agentId
   // P-34fa5d79 — pre-build the wiId → notes map so each item's _notes lookup
   // is O(1) instead of re-scanning inbox+archive per item.
   const _notesByWi = _buildNotesByWiMap();
@@ -1996,14 +2008,25 @@ function getWorkItems(config, opts) {
       // Notes: inbox → KB (via source field) → archive (fallback if KB was swept)
       const itemId = item.id || '___';
       const matchInbox = _inboxFiles.filter(f => f.includes(agentId) && f.includes(itemId));
-      const matchKb = _kbEntries.filter(kb => kb.source && kb.source.includes(agentId) && kb.source.includes(itemId));
+      // Lazily bucket KB by agentId (computed once per distinct agent), then
+      // filter the small bucket by itemId — same result as filtering all of
+      // _kbEntries by (agentId AND itemId), without the per-item full scan.
+      if (_kbByAgent[agentId] === undefined) {
+        _kbByAgent[agentId] = _kbEntries.filter(kb => kb.source && kb.source.includes(agentId));
+      }
+      const matchKb = _kbByAgent[agentId].filter(kb => kb.source.includes(itemId));
       const allNotes = [
         ...matchInbox,
         ...matchKb.map(kb => 'kb:' + kb.cat + '/' + kb.file),
       ];
-      // Archive fallback — only if nothing found in inbox or KB
+      // Archive fallback — only if nothing found in inbox or KB. Same agentId
+      // bucketing as KB so the (potentially large) archive list isn't fully
+      // re-scanned per item.
       if (allNotes.length === 0) {
-        const matchArchive = _archiveFiles.filter(f => f.includes(agentId) && f.includes(itemId));
+        if (_archiveByAgent[agentId] === undefined) {
+          _archiveByAgent[agentId] = _archiveFiles.filter(f => f.includes(agentId));
+        }
+        const matchArchive = _archiveByAgent[agentId].filter(f => f.includes(itemId));
         for (const f of matchArchive) allNotes.push('archive:' + f);
       }
       if (allNotes.length > 0) arts.notes = _mergeArtifactNotes(arts.notes, allNotes);

package/engine.js

@@ -8782,18 +8782,41 @@ function discoverCentralWorkItems(config) {
         // the renderPlaybook pass logs an "unresolved template variables" warning
         // every time a fresh plan-to-prd dispatches.
         vars.existing_prd_json = '';
-        // Check if a PRD already exists for this plan — reuse its filename to avoid duplicates (#884)
+        // Check if a PRD already exists for this plan — reuse its filename to
+        // avoid duplicates (#884). Match by BASENAME (not exact string) so a
+        // `plans/` prefix or separator difference between item.planFile and a
+        // PRD's source_plan can't fork a duplicate PRD (#415 class).
         let prdFilename = null;
+        const planKey = path.basename(String(item.planFile || ''));
         const prdFiles = safeReadDir(PRD_DIR).filter(f => f.endsWith('.json'));
         for (const pf of prdFiles) {
           const prd = safeJson(path.join(PRD_DIR, pf));
-          if (prd?.source_plan === item.planFile) {
+          if (planKey && prd && path.basename(String(prd.source_plan || '')) === planKey) {
             prdFilename = pf;
             try { vars.existing_prd_json = fs.readFileSync(path.join(PRD_DIR, pf), 'utf8'); } catch (_) { /* ignore */ }
             log('info', `plan-to-prd: reusing existing PRD "${pf}" for plan "${item.planFile}" (#884)`);
             break;
           }
         }
+        // Same-plan in-flight reuse (dedup hardening): no on-disk PRD found, but
+        // if ANOTHER plan-to-prd item for the SAME plan already pinned a
+        // _prdFilename — a sibling WI from a prior tick, or another item being
+        // prepared this same tick — REUSE it so concurrent/repeat plan-to-prd
+        // runs for one plan converge to a single PRD instead of splitting into
+        // <slug>-<date>.json / -2.json / -3.json. Match by basename.
+        if (!prdFilename && planKey) {
+          for (const otherItem of items) {
+            if (!otherItem || otherItem.id === item.id || !otherItem._prdFilename) continue;
+            if (path.basename(String(otherItem.planFile || '')) === planKey) { prdFilename = otherItem._prdFilename; break; }
+          }
+          if (!prdFilename) {
+            for (const [otherId, m] of mutations) {
+              if (otherId === item.id || !m || !m._prdFilename) continue;
+              if (m._planKey && m._planKey === planKey) { prdFilename = m._prdFilename; break; }
+            }
+          }
+          if (prdFilename) log('info', `plan-to-prd: reusing in-flight PRD "${prdFilename}" for plan "${item.planFile}" (same-plan dedup)`);
+        }
         if (!prdFilename) {
           // Generate unique PRD filename — check prd/, prd/archive/, AND any
           // _prdFilename already pinned by sibling work items (W-mozkn1bb001j66fd):
@@ -8832,7 +8855,9 @@ function discoverCentralWorkItems(config) {
           while (prdExisting.has(prdFilename)) { prdFilename = prdBase + '-' + prdCounter + '.json'; prdCounter++; }
         }
         vars.prd_filename = prdFilename;
-        mutations.set(item.id, Object.assign(mutations.get(item.id) || {}, { _prdFilename: prdFilename }));
+        // Pin _planKey alongside _prdFilename so the same-plan in-flight reuse
+        // above can recognize a sibling prepared earlier THIS tick by plan.
+        mutations.set(item.id, Object.assign(mutations.get(item.id) || {}, { _prdFilename: prdFilename, _planKey: planKey }));
         vars.branch_strategy_hint = item.branchStrategy
           ? `The user requested **${item.branchStrategy}** strategy. Use this unless the analysis strongly suggests otherwise.`
           : 'Choose the best strategy based on your analysis of item dependencies.';

package/package.json

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