@yemi33/minions 0.1.828 → 0.1.830

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Changelog
 
-## 0.1.828 (2026-04-11)
+## 0.1.830 (2026-04-11)
 
 ### Features
 -  stale PRD shows Regenerate PRD + Resume as-is buttons
@@ -11,6 +11,10 @@
 -  hide conflicting action buttons when stale PRD banner is showing
 -  diff-aware plan-to-prd triggered by Resume, not auto-dispatch
 
+### Other
+- refactor: add PRD_ITEM_STATUS/PRD_MATERIALIZABLE constants, extract queuePlanToPrd
+- refactor: remove dead criteria variable, DRY plan resume functions
+
 ## 0.1.823 (2026-04-11)
 
 ### Features

package/dashboard/js/render-prd.js

@@ -766,16 +766,16 @@ async function prdItemRequeue(workItemId, source, prdFile) {
   }
 }
 
-async function prdRegenerate(prdFile) {
-  if (!confirm('Source plan was revised.\n\nRegenerate PRD? An agent will compare the updated plan against existing implementation and update items accordingly.\n\nDone items stay done unless modified. New items are added. Removed items are cancelled.')) return;
+async function _planApproveAction(prdFile, skipRegen, confirmMsg, successMsg) {
+  if (!confirm(confirmMsg)) return;
   try {
     const res = await fetch('/api/plans/approve', {
       method: 'POST', headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ file: prdFile })
+      body: JSON.stringify({ file: prdFile, skipRegen: skipRegen || undefined })
     });
     const d = await res.json();
     if (res.ok) {
-      showToast('cmd-toast', d.diffAwareUpdate ? 'Diff-aware PRD update queued' : 'Plan approved', true);
+      showToast('cmd-toast', successMsg || (d.diffAwareUpdate ? 'Diff-aware PRD update queued' : 'Plan approved'), true);
       refresh();
     } else {
       alert('Failed: ' + (d.error || 'unknown'));
@@ -783,21 +783,15 @@ async function prdRegenerate(prdFile) {
   } catch (e) { alert('Error: ' + e.message); }
 }
 
-async function prdResumeWithoutRegen(prdFile) {
-  if (!confirm('Resume this plan without regenerating the PRD?\n\nThe current PRD items will be used as-is. New work items will be materialized from any missing/planned items.')) return;
-  try {
-    const res = await fetch('/api/plans/approve', {
-      method: 'POST', headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ file: prdFile, skipRegen: true })
-    });
-    const d = await res.json();
-    if (res.ok) {
-      showToast('cmd-toast', 'Plan resumed (PRD unchanged)', true);
-      refresh();
-    } else {
-      alert('Failed: ' + (d.error || 'unknown'));
-    }
-  } catch (e) { alert('Error: ' + e.message); }
+function prdRegenerate(prdFile) {
+  _planApproveAction(prdFile, false,
+    'Source plan was revised.\n\nRegenerate PRD? An agent will compare the updated plan against existing implementation and update items accordingly.\n\nDone items stay done unless modified. New items are added. Removed items are cancelled.');
+}
+
+function prdResumeWithoutRegen(prdFile) {
+  _planApproveAction(prdFile, true,
+    'Resume this plan without regenerating the PRD?\n\nThe current PRD items will be used as-is. New work items will be materialized from any missing/planned items.',
+    'Plan resumed (PRD unchanged)');
 }
 
 function openArchive(i) {

package/dashboard.js

@@ -2247,34 +2247,21 @@ If nothing to do: { "duplicates": [], "reclassify": [], "remove": [] }`;
         const projectName = plan.project || body.file.replace(/-\d{4}-\d{2}-\d{2}\.json$/, '');
         const targetProject = PROJECTS.find(p => p.name?.toLowerCase() === projectName.toLowerCase()) || PROJECTS[0];
         if (targetProject) {
-          const centralWiPath = path.join(MINIONS_DIR, 'work-items.json');
-          mutateJsonFileLocked(centralWiPath, items => {
-            if (!Array.isArray(items)) items = [];
-            if (items.some(w => w.type === 'plan-to-prd' && w.planFile === plan.source_plan && (w.status === 'pending' || w.status === 'dispatched'))) return items;
-            items.push({
-              id: 'W-' + shared.uid(),
-              title: `Update PRD from revised plan: ${plan.source_plan}`,
-              type: 'plan-to-prd',
-              priority: 'high',
-              description: `Plan file: plans/${plan.source_plan}\nPRD file: prd/${body.file}\n\n` +
-                `Source plan was revised. Compare the updated plan against existing PRD and produce an updated version.\n\n` +
-                `**Current PRD implementation state:**\n${implContext}\n\n` +
-                `**Rules for updating:**\n` +
-                `- Items that are done and unchanged in the plan → keep status "done" (preserve their ID)\n` +
-                `- Items that are done but modified in the plan (new requirements) → set status "updated" (engine will re-open)\n` +
-                `- New items in the plan → set status "missing" (engine will materialize)\n` +
-                `- Items removed from the plan → drop from PRD (engine will cancel pending WIs)\n` +
-                `- Preserve all existing item IDs for unchanged/modified items — do NOT generate new IDs for them`,
-              status: 'pending',
-              created: new Date().toISOString(),
-              createdBy: 'dashboard:plan-resume',
-              project: targetProject.name,
-              planFile: plan.source_plan,
-              _existingPrdFile: body.file,
-            });
-            diffAwareQueued = true;
-            return items;
-          }, { defaultValue: [] });
+          diffAwareQueued = shared.queuePlanToPrd({
+            planFile: plan.source_plan, prdFile: body.file,
+            title: `Update PRD from revised plan: ${plan.source_plan}`,
+            description: `Plan file: plans/${plan.source_plan}\nPRD file: prd/${body.file}\n\n` +
+              `Source plan was revised. Compare the updated plan against existing PRD and produce an updated version.\n\n` +
+              `**Current PRD implementation state:**\n${implContext}\n\n` +
+              `**Rules for updating:**\n` +
+              `- Items that are done and unchanged in the plan → keep status "done" (preserve their ID)\n` +
+              `- Items that are done but modified in the plan (new requirements) → set status "updated" (engine will re-open)\n` +
+              `- New items in the plan → set status "missing" (engine will materialize)\n` +
+              `- Items removed from the plan → drop from PRD (engine will cancel pending WIs)\n` +
+              `- Preserve all existing item IDs for unchanged/modified items — do NOT generate new IDs for them`,
+            project: targetProject.name, createdBy: 'dashboard:plan-resume',
+            extra: { _existingPrdFile: body.file },
+          });
         }
       }
 

package/engine/shared.js

@@ -587,6 +587,8 @@ const PLAN_STATUS = {
   PAUSED: 'paused', REJECTED: 'rejected', COMPLETED: 'completed',
   REVISION_REQUESTED: 'revision-requested',
 };
+const PRD_ITEM_STATUS = { MISSING: 'missing', PLANNED: 'planned', UPDATED: 'updated', DONE: 'done' };
+const PRD_MATERIALIZABLE = new Set([PRD_ITEM_STATUS.MISSING, PRD_ITEM_STATUS.PLANNED, PRD_ITEM_STATUS.UPDATED]);
 const PR_STATUS = { ACTIVE: 'active', MERGED: 'merged', ABANDONED: 'abandoned', CLOSED: 'closed', LINKED: 'linked' };
 // PRs eligible for polling (status/build/comment checks) — excludes terminal statuses
 const PR_POLLABLE_STATUSES = new Set([PR_STATUS.ACTIVE, PR_STATUS.LINKED]);
@@ -605,6 +607,32 @@ function trackReviewMetric(pr, newReviewStatus, config) {
     });
   } catch (err) { log('warn', `Metrics update: ${err.message}`); }
 }
+
+/** Queue a plan-to-prd work item with dedup check inside lock. Returns true if queued. */
+function queuePlanToPrd({ planFile, prdFile, title, description, project, createdBy, extra }) {
+  const centralWiPath = path.join(__dirname, '..', 'work-items.json');
+  let queued = false;
+  mutateJsonFileLocked(centralWiPath, items => {
+    if (!Array.isArray(items)) items = [];
+    if (items.some(w => w.type === 'plan-to-prd' && w.planFile === planFile && (w.status === 'pending' || w.status === 'dispatched'))) return items;
+    items.push({
+      id: 'W-' + uid(),
+      title,
+      type: 'plan-to-prd',
+      priority: 'high',
+      description,
+      status: 'pending',
+      created: new Date().toISOString(),
+      createdBy,
+      project,
+      planFile,
+      ...(extra || {}),
+    });
+    queued = true;
+    return items;
+  }, { defaultValue: [] });
+  return queued;
+}
 const DISPATCH_RESULT = { SUCCESS: 'success', ERROR: 'error', TIMEOUT: 'timeout' };
 const PIPELINE_STATUS = {
   PENDING: 'pending', RUNNING: 'running', COMPLETED: 'completed',
@@ -1021,7 +1049,7 @@ module.exports = {
   KB_CATEGORIES,
   classifyInboxItem,
   ENGINE_DEFAULTS,
-  WI_STATUS, DONE_STATUSES, PLAN_TERMINAL_STATUSES, WORK_TYPE, PLAN_STATUS, PR_STATUS, PR_POLLABLE_STATUSES, DISPATCH_RESULT, trackReviewMetric,
+  WI_STATUS, DONE_STATUSES, PLAN_TERMINAL_STATUSES, WORK_TYPE, PLAN_STATUS, PRD_ITEM_STATUS, PRD_MATERIALIZABLE, PR_STATUS, PR_POLLABLE_STATUSES, DISPATCH_RESULT, trackReviewMetric, queuePlanToPrd,
   PIPELINE_STATUS, STAGE_TYPE, MEETING_STATUS, AGENT_STATUS,
   FAILURE_CLASS, ESCALATION_POLICY, COMPLETION_FIELDS,
   DEFAULT_AGENT_METRICS,

package/engine.js

@@ -25,7 +25,7 @@ const fs = require('fs');
 const path = require('path');
 const shared = require('./engine/shared');
 const { exec, execAsync, execSilent, runFile, ts, ENGINE_DEFAULTS: DEFAULTS,
-  WI_STATUS, DONE_STATUSES, WORK_TYPE, PLAN_STATUS, PR_STATUS, DISPATCH_RESULT, AGENT_STATUS } = shared;
+  WI_STATUS, DONE_STATUSES, WORK_TYPE, PLAN_STATUS, PRD_MATERIALIZABLE, PR_STATUS, DISPATCH_RESULT, AGENT_STATUS } = shared;
 const queries = require('./engine/queries');
 
 // ─── Paths ──────────────────────────────────────────────────────────────────
@@ -1358,26 +1358,12 @@ function materializePlansAsWorkItems(config) {
               const allProjects = getProjects(config);
               const targetProject = allProjects.find(p => p.name?.toLowerCase() === projectName.toLowerCase()) || allProjects[0];
               if (targetProject) {
-                const centralWiPath = path.join(MINIONS_DIR, 'work-items.json');
-                let queued = false;
-                mutateJsonFileLocked(centralWiPath, items => {
-                  if (!Array.isArray(items)) items = [];
-                  if (items.some(w => w.type === WORK_TYPE.PLAN_TO_PRD && w.planFile === plan.source_plan && (w.status === WI_STATUS.PENDING || w.status === WI_STATUS.DISPATCHED))) return items;
-                  items.push({
-                    id: 'W-' + shared.uid(),
-                    title: `Regenerate PRD from revised plan: ${plan.source_plan}`,
-                    type: 'plan-to-prd',
-                    priority: 'high',
-                    description: `Plan file: plans/${plan.source_plan}\nSource plan was revised (PRD was ${prdStatus}) — regenerating.${completedContext}`,
-                    status: 'pending',
-                    created: ts(),
-                    createdBy: 'engine:plan-revision',
-                    project: targetProject.name,
-                    planFile: plan.source_plan,
-                  });
-                  queued = true;
-                  return items;
-                }, { defaultValue: [] });
+                const queued = shared.queuePlanToPrd({
+                  planFile: plan.source_plan, prdFile: file,
+                  title: `Regenerate PRD from revised plan: ${plan.source_plan}`,
+                  description: `Plan file: plans/${plan.source_plan}\nSource plan was revised (PRD was ${prdStatus}) — regenerating.${completedContext}`,
+                  project: targetProject.name, createdBy: 'engine:plan-revision',
+                });
                 if (queued) log('info', `Queued plan-to-prd regeneration for revised plan ${plan.source_plan} (${completedItems.length} completed items to carry over)`);
               }
             }
@@ -1417,14 +1403,14 @@ function materializePlansAsWorkItems(config) {
     // No project found — use central work-items.json (engine works without projects)
     const useCentral = !defaultProject;
 
-    const statusFilter = ['missing', 'planned', 'updated'];
+    const statusFilter = PRD_MATERIALIZABLE;
     // Also materialize in-pr/done items that never got a work item (race with PR status sync)
     const allExistingWiIds = new Set();
     for (const w of queries.getWorkItems()) {
       if (w.id) allExistingWiIds.add(w.id);
     }
     const items = plan.missing_features.filter(f =>
-      statusFilter.includes(f.status) ||
+      statusFilter.has(f.status) ||
       (DONE_STATUSES.has(f.status) && f.id && !allExistingWiIds.has(f.id))
     );
 
@@ -1474,11 +1460,10 @@ function materializePlansAsWorkItems(config) {
         for (const item of projItems) {
           // Re-open: PRD item set back to missing/planned/updated but work item is done → reset to pending
           const existingWi = existingItems.find(w => w.id === item.id);
-          const shouldReopen = item.status === 'missing' || item.status === 'planned' || item.status === 'updated';
+          const shouldReopen = PRD_MATERIALIZABLE.has(item.status);
           if (existingWi && DONE_STATUSES.has(existingWi.status) && shouldReopen) {
             existingWi.status = WI_STATUS.PENDING;
             existingWi._reopened = true;
-            const criteria = (item.acceptance_criteria || []).map(c => `- ${c}`).join('\n');
             existingWi.description = buildWiDescription(item, file);
             existingWi.title = `Implement: ${item.name}`;
             created++;

package/package.json

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