@yemi33/minions 0.1.327 → 0.1.329

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.1.329 (2026-04-03)
+
+### Fixes
+-  remove orphan statuses, add validation, replace in-progress with dispatched
+
+## 0.1.328 (2026-04-03)
+
+### Fixes
+-  import PR_STATUS in engine.js — was causing discoverWork to fail
+
 ## 0.1.327 (2026-04-03)
 
 ### Fixes

package/dashboard/js/render-plans.js

@@ -83,7 +83,7 @@ function derivePlanStatus(prdFile, mdFile, prdJsonStatus, workItems) {
 
   // Derive from work item progress
   if (allDone && !hasActiveWork) return 'completed';
-  if (hasActiveWork || hasPendingPrd) return 'in-progress';
+  if (hasActiveWork || hasPendingPrd) return 'dispatched';
   if (hasFailed && !hasActiveWork) return 'has-failures';
 
   if (prdJsonStatus === 'awaiting-approval' && implementWi.length === 0) return 'awaiting-approval';
@@ -192,7 +192,7 @@ function renderPlans(plans) {
     const effectiveStatus = isArchived ? 'completed' : derivePlanStatus(prdFile, p.file, prdJsonStatus, allWi);
 
     const statusLabelsMap = {
-      'completed': 'Completed', 'in-progress': 'In Progress', 'paused': 'Paused',
+      'completed': 'Completed', 'dispatched': 'In Progress', 'paused': 'Paused',
       'awaiting-approval': 'Awaiting Approval', 'approved': 'Approved', 'rejected': 'Rejected',
       'revision-requested': 'Revision Requested', 'has-failures': 'Has Failures', 'active': 'Active'
     };
@@ -225,7 +225,7 @@ function renderPlans(plans) {
 
     const executeBtn = isDraft && (effectiveStatus === 'active' || effectiveStatus === 'draft') && !isArchived && !prdFile ? '<button class="pr-pager-btn" style="font-size:9px;padding:2px 8px;color:var(--green);font-weight:600" ' +
       'onclick="event.stopPropagation();planExecute(\'' + escHtml(p.file) + '\',\'' + escHtml(p.project) + '\',this)">Execute</button>' : '';
-    const showPause = effectiveStatus === 'in-progress' && prdFile && !isArchived;
+    const showPause = effectiveStatus === 'dispatched' && prdFile && !isArchived;
     const showResume = (effectiveStatus === 'paused' || effectiveStatus === 'awaiting-approval') && prdFile && !isArchived;
     const verifyWi = allWi.find(w => w.itemType === 'verify' && w.sourcePlan === prdFile);
     const hasVerifyWi = !!verifyWi;
@@ -246,8 +246,8 @@ function renderPlans(plans) {
       'onclick="event.stopPropagation();planDelete(\'' + escHtml(p.file) + '\')">Delete</button>' : '';
 
     const versionBadge = p.version ? ' <span style="font-size:9px;font-weight:700;padding:1px 5px;border-radius:3px;background:rgba(56,139,253,0.15);color:var(--blue);vertical-align:middle">v' + p.version + '</span>' : '';
-    const statusColors = { 'completed': 'var(--green)', 'in-progress': 'var(--blue)', 'paused': 'var(--muted)', 'awaiting-approval': 'var(--yellow)', 'approved': 'var(--green)', 'rejected': 'var(--red)', 'has-failures': 'var(--red)', 'revision-requested': 'var(--purple,#a855f7)', 'active': 'var(--muted)' };
-    const cardClass = effectiveStatus === 'in-progress' ? 'working' : effectiveStatus === 'awaiting-approval' || effectiveStatus === 'paused' ? 'awaiting' : effectiveStatus;
+    const statusColors = { 'completed': 'var(--green)', 'dispatched': 'var(--blue)', 'paused': 'var(--muted)', 'awaiting-approval': 'var(--yellow)', 'approved': 'var(--green)', 'rejected': 'var(--red)', 'has-failures': 'var(--red)', 'revision-requested': 'var(--purple,#a855f7)', 'active': 'var(--muted)' };
+    const cardClass = effectiveStatus === 'dispatched' ? 'working' : effectiveStatus === 'awaiting-approval' || effectiveStatus === 'paused' ? 'awaiting' : effectiveStatus;
     return '<div class="plan-card ' + cardClass + '" data-file="plans/' + escHtml(p.file) + '" style="cursor:pointer' + (isArchived ? ';opacity:0.7' : '') + '" onclick="planView(\'' + escHtml(p.file) + '\')">' +
       '<div class="plan-card-header">' +
         '<div><div class="plan-card-title">' + escHtml(p.summary || p.file) + versionBadge + '</div>' +

package/dashboard/js/render-prd.js

@@ -13,8 +13,8 @@ function renderPrd(prd, prog) {
     return;
   }
 
-  const statusColors = { 'completed': 'var(--green)', 'in-progress': 'var(--blue)', 'awaiting-approval': 'var(--yellow)', 'paused': 'var(--muted)', 'approved': 'var(--green)' };
-  const statusLabels = { 'completed': 'Completed', 'in-progress': 'In Progress', 'awaiting-approval': 'Awaiting Approval', 'paused': 'Paused', 'approved': 'Approved' };
+  const statusColors = { 'completed': 'var(--green)', 'dispatched': 'var(--blue)', 'awaiting-approval': 'var(--yellow)', 'paused': 'var(--muted)', 'approved': 'var(--green)' };
+  const statusLabels = { 'completed': 'Completed', 'dispatched': 'In Progress', 'awaiting-approval': 'Awaiting Approval', 'paused': 'Paused', 'approved': 'Approved' };
 
   // Show per-PRD status summary in header when multiple PRDs exist
   const existing = prd.existing || [];
@@ -28,7 +28,7 @@ function renderPrd(prd, prog) {
     const hasActive = implementItems.some(w => w.status === 'pending' || w.status === 'dispatched');
     const prdFile = existing[0]?.file || '';
     const prdStatus = existing[0]?.status || '';
-    const effectiveStatus = allDone && !hasActive ? 'completed' : hasActive ? 'in-progress' : prdStatus || 'active';
+    const effectiveStatus = allDone && !hasActive ? 'completed' : hasActive ? 'dispatched' : prdStatus || 'active';
 
     let actions = '';
     if (prdFile) {
@@ -37,7 +37,7 @@ function renderPrd(prd, prog) {
       } else if (effectiveStatus === 'completed') {
         actions = ' <button class="pr-pager-btn" style="font-size:9px;padding:1px 6px;color:var(--green);border-color:var(--green);margin-left:4px" onclick="triggerVerify(\'' + escHtml(prdFile) + '\',this)">Verify</button>' +
           ' <button class="pr-pager-btn" style="font-size:9px;padding:1px 6px;margin-left:4px" onclick="planArchive(\'' + escHtml(prdFile) + '\',this)">Archive</button>';
-      } else if (effectiveStatus === 'in-progress') {
+      } else if (effectiveStatus === 'dispatched') {
         actions = ' <button class="pr-pager-btn" style="font-size:9px;padding:1px 6px;color:var(--yellow);border-color:var(--yellow);margin-left:4px" onclick="planPause(\'' + escHtml(prdFile) + '\',this)">Pause</button>';
       } else if (effectiveStatus === 'paused') {
         actions = ' <button class="pr-pager-btn" style="font-size:9px;padding:1px 6px;color:var(--green);border-color:var(--green);margin-left:4px" onclick="planApprove(\'' + escHtml(prdFile) + '\',this)">Resume</button>' +
@@ -48,13 +48,13 @@ function renderPrd(prd, prog) {
       ' <span style="color:var(--muted);font-size:10px">' + (prd.age || '') + '</span>' + actions;
   } else {
     // Multiple PRDs — show count summary, per-PRD details are in renderPrdProgress groups
-    const counts = { completed: 0, 'in-progress': 0, 'awaiting-approval': 0, paused: 0 };
+    const counts = { completed: 0, 'dispatched': 0, 'awaiting-approval': 0, paused: 0 };
     for (const p of existing) {
       const items = prdItems.filter(i => i.source === p.file);
       const wiForPrd = allWi.filter(w => items.some(pi => pi.id === w.id));
       const allDone = wiForPrd.length > 0 && wiForPrd.every(w => w.status === 'done');
       const hasActive = wiForPrd.some(w => w.status === 'pending' || w.status === 'dispatched');
-      const s = allDone && !hasActive ? 'completed' : hasActive ? 'in-progress' : p.status || 'active';
+      const s = allDone && !hasActive ? 'completed' : hasActive ? 'dispatched' : p.status || 'active';
       counts[s] = (counts[s] || 0) + 1;
     }
     const parts = Object.entries(counts).filter(([, n]) => n > 0).map(([s, n]) =>
@@ -83,7 +83,7 @@ function renderPrdProgress(prog) {
     const total = items.length;
     if (total === 0) return '';
     const done = items.filter(i => i.status === 'done').length;
-    const inProgress = items.filter(i => i.status === 'in-progress').length;
+    const inProgress = items.filter(i => i.status === 'dispatched').length;
     const failed = items.filter(i => i.status === 'failed').length;
     const paused = items.filter(i => i.status === 'paused').length;
     const missing = items.filter(i => i.status === 'missing' || !i.status).length;
@@ -100,7 +100,7 @@ function renderPrdProgress(prog) {
 
     const bar = '<div class="prd-progress-bar">' +
       '<div class="seg complete" style="width:' + pct(done) + '%"></div>' +
-      '<div class="seg in-progress" style="width:' + pct(inProgress) + '%"></div>' +
+      '<div class="seg dispatched" style="width:' + pct(inProgress) + '%"></div>' +
       '<div class="seg paused" style="width:' + pct(paused) + '%"></div>' +
       '<div class="seg missing" style="width:' + pct(missing) + '%"></div>' +
     '</div>';
@@ -108,15 +108,15 @@ function renderPrdProgress(prog) {
     return '<div style="margin:6px 0 8px 0;padding:0 8px">' + stats + '<div style="margin-top:8px">' + bar + '</div></div>';
   }
 
-  // PRD item statuses: missing → in-progress → done
+  // PRD item statuses: missing → dispatched → done
   const statusBadge = (s) => {
     const styles = {
       'done': 'background:rgba(63,185,80,0.15);color:var(--green)',
-      'in-progress': 'background:rgba(210,153,34,0.15);color:var(--yellow);animation:wipPulse 1.5s infinite',
+      'dispatched': 'background:rgba(210,153,34,0.15);color:var(--yellow);animation:wipPulse 1.5s infinite',
       'failed':      'background:rgba(248,81,73,0.15);color:var(--red)',
       'paused':      'background:rgba(139,148,158,0.15);color:var(--muted)',
     };
-    const labels = { 'done': 'DONE', 'in-progress': 'WIP', 'failed': 'FAIL', 'paused': 'PAUSED', 'missing': '\u2014' };
+    const labels = { 'done': 'DONE', 'dispatched': 'WIP', 'failed': 'FAIL', 'paused': 'PAUSED', 'missing': '\u2014' };
     const style = styles[s] || 'background:var(--surface);color:var(--muted)';
     const label = labels[s] || '—';
     return '<span style="font-size:9px;font-weight:700;padding:2px 6px;border-radius:3px;letter-spacing:0.5px;white-space:nowrap;' + style + '">' + label + '</span>';
@@ -196,7 +196,7 @@ function renderPrdProgress(prog) {
 
   const renderGroupHeader = (g) => {
     const done = g.items.filter(i => i.status === 'done').length;
-    const wip = g.items.filter(i => i.status === 'in-progress' || i.status === 'dispatched').length;
+    const wip = g.items.filter(i => i.status === 'dispatched' || i.status === 'dispatched').length;
     const summary = (g.summary || '').replace(/^Convert plan to PRD:\s*/i, '').slice(0, 80);
     const isAwaitingApproval = g.planStatus === 'awaiting-approval';
     const isPaused = g.planStatus === 'paused';
@@ -303,7 +303,7 @@ function renderPrdProgress(prog) {
 
     const statusColor = (s) => {
       if (s === 'done') return 'var(--green)';
-      if (s === 'in-progress') return 'var(--yellow)';
+      if (s === 'dispatched') return 'var(--yellow)';
       if (s === 'failed') return 'var(--red)';
       if (s === 'paused') return 'var(--muted)';
       return 'var(--border)';
@@ -322,7 +322,7 @@ function renderPrdProgress(prog) {
         const iid = escHtml(i.id || '');
         const agent = wi[i.id]?.dispatched_to || '';
         const deps = (i.depends_on || []).join(', ');
-        const wipAnim = i.status === 'in-progress' ? 'animation:prdWipPulse 2s infinite;' : '';
+        const wipAnim = i.status === 'dispatched' ? 'animation:prdWipPulse 2s infinite;' : '';
         html += '<div onclick="prdItemEdit(\'' + src + '\',\'' + iid + '\')" ' +
           'style="background:var(--surface2);border:1px solid var(--border);border-left:3px solid ' + borderColor + ';' + wipAnim +
           'border-radius:4px;padding:6px 8px;margin-bottom:6px;cursor:pointer;font-size:11px">' +
@@ -557,7 +557,7 @@ async function prdItemEdit(source, itemId) {
   let completionHtml = '';
   const isDone = item.status === 'done';
   const isFailed = item.status === 'failed';
-  const isActive = item.status === 'in-progress' || item.status === 'dispatched';
+  const isActive = item.status === 'dispatched' || item.status === 'dispatched';
 
   if (isDone || isFailed || isActive) {
     const agent = wi?.dispatched_to || completedEntry?.agent || '';

package/dashboard/js/render-work-items.js

@@ -30,7 +30,7 @@ function wiRetryBtn(item) {
 
 function wiRow(item) {
   const statusBadge = (s) => {
-    const cls = s === 'failed' ? 'rejected' : s === 'needs-human-review' ? 'needs-review' : s === 'dispatched' ? 'building' : s === 'pending' || s === 'queued' ? 'active' : s === 'done' ? 'approved' : 'draft';
+    const cls = s === 'failed' ? 'rejected' : s === 'needs-human-review' ? 'needs-review' : s === 'dispatched' ? 'building' : s === 'pending' || s === 'queued' ? 'active' : s === 'done' ? 'approved' : s === 'decomposed' ? 'building' : 'draft';
     return '<span class="pr-badge ' + cls + '">' + escHtml(s) + '</span>';
   };
   const typeBadge = (t) => '<span class="dispatch-type ' + (t || 'implement') + '">' + escHtml(t || 'implement') + '</span>';

package/dashboard/styles.css

@@ -168,7 +168,7 @@
   .prd-progress-bar { width: 100%; height: 20px; background: var(--bg); border-radius: var(--radius-xl); overflow: hidden; display: flex; margin-bottom: var(--space-6); border: 1px solid var(--border); }
   .prd-progress-bar .seg { height: 100%; transition: width 0.5s ease; }
   .prd-progress-bar .seg.complete { background: var(--green); }
-  .prd-progress-bar .seg.in-progress { background: var(--yellow); }
+  .prd-progress-bar .seg.dispatched { background: var(--yellow); }
   .prd-progress-bar .seg.paused { background: var(--muted); opacity: 0.5; }
   .prd-progress-bar .seg.missing { background: var(--border); }
   .prd-progress-pct { font-size: 22px; font-weight: 700; color: var(--green); margin-bottom: var(--space-4); }
@@ -176,7 +176,7 @@
   .prd-legend-item { display: flex; align-items: center; gap: 5px; font-size: var(--text-base); color: var(--muted); }
   .prd-legend-dot { width: 10px; height: 10px; border-radius: 2px; }
   .prd-legend-dot.complete { background: var(--green); }
-  .prd-legend-dot.in-progress { background: var(--yellow); }
+  .prd-legend-dot.dispatched { background: var(--yellow); }
   .prd-legend-dot.missing { background: var(--border); }
 
   /* Pipeline Step-Progress */
@@ -193,7 +193,7 @@
   .prd-items-list { display: flex; flex-direction: column; gap: 3px; max-height: 400px; overflow-y: auto; padding: 0 8px; }
   .prd-item-row { display: flex; align-items: center; gap: 8px; padding: 4px 8px; border-radius: var(--radius-sm); font-size: var(--text-base); background: var(--surface2); border: 1px solid var(--border); border-left: 3px solid var(--border); }
   .prd-item-row.st-done { border-left-color: var(--green); }
-  .prd-item-row.st-in-progress { border-left-color: var(--yellow); animation: prdWipPulse 2s infinite; }
+  .prd-item-row.st-dispatched { border-left-color: var(--yellow); animation: prdWipPulse 2s infinite; }
   @keyframes prdWipPulse { 0%, 100% { box-shadow: 0 0 0 0 rgba(210,153,34,0); } 50% { box-shadow: 0 0 0 4px rgba(210,153,34,0.2); } }
   .prd-item-row.st-failed { border-left-color: var(--red); }
   .prd-item-row.st-needs-human-review { border-left-color: var(--orange); }

package/engine/cli.js

@@ -809,8 +809,8 @@ const commands = {
         if (exists && name === 'prd') {
           const prd = safeJson(filePath);
           if (prd) {
-            const missing = (prd.missing_features || []).filter(f => ['missing', 'planned'].includes(f.status));
-            console.log(`    Items: ${missing.length} missing/planned features`);
+            const missing = (prd.missing_features || []).filter(f => f.status === 'missing' || !f.status);
+            console.log(`    Items: ${missing.length} missing features`);
           }
         }
         if (exists && name === 'pullRequests') {

package/engine/lifecycle.js

@@ -23,9 +23,8 @@ function checkPlanCompletion(meta, config) {
   const planPath = path.join(PRD_DIR, planFile);
   const plan = safeJson(planPath);
   if (!plan?.missing_features) return;
-  if (plan.status === 'completed') {
+  if (plan.status === PLAN_STATUS.COMPLETED) {
     if (plan._completionNotified) return;
-    // Crash recovery: status=completed but _completionNotified not set — fall through
   }
 
   const projects = shared.getProjects(config);
@@ -81,7 +80,7 @@ function checkPlanCompletion(meta, config) {
   const failedItems = planItems.filter(w => w.status === WI_STATUS.FAILED);
 
   // 1. Mark plan as completed
-  plan.status = 'completed';
+  plan.status = PLAN_STATUS.COMPLETED;
   plan.completedAt = ts();
 
   // Compute timing
@@ -137,30 +136,15 @@ function checkPlanCompletion(meta, config) {
     ...uniquePrs.map(pr => `- ${pr.id}: ${pr.title || ''} ${pr.url || ''}`),
   ].filter(Boolean).join('\n');
 
-  // Write summary to notes/inbox (slug-based dedup prevents duplicates on same day)
-  const slug = `prd-completion-${planFile.replace('.json', '')}`;
-  const wrote = shared.writeToInbox('engine', slug, summary);
-  if (wrote) log('info', `PRD completion summary written to notes/inbox/`);
-
-  // Persist status and _completionNotified atomically BEFORE creating work items
-  // NOTE: Do NOT set plan._completionNotified in-memory before persist —
-  // if persist fails, the in-memory flag would prevent retry on next tick.
-  mutateJsonFileLocked(planPath, (data) => {
-    data.status = 'completed';
-    data.completedAt = plan.completedAt;
-    data._completionNotified = true;
-    if (plan._timing) data._timing = plan._timing;
-    return data;
-  });
+  // Write summary to notes/inbox
+  const summaryFile = `prd-completion-${planFile.replace('.json', '')}-${ts().slice(0, 10)}.md`;
+  shared.safeWrite(shared.uniquePath(path.join(MINIONS_DIR, 'notes', 'inbox', summaryFile)), summary);
+  log('info', `PRD completion summary written to notes/inbox/${summaryFile}`);
 
   // Resolve the primary project for writing new work items (PR, verify)
   const projectName = plan.project;
   const primaryProject = projectName
-    ? projects.find(p => p.name?.toLowerCase() === projectName?.toLowerCase()) : (projects[0] || null);
-  if (!primaryProject) {
-    log('warn', `checkPlanCompletion: no project available (projects array ${projects.length === 0 ? 'empty' : 'no match for ' + projectName}) — skipping PR/verify creation for ${planFile}`);
-    return;
-  }
+    ? projects.find(p => p.name?.toLowerCase() === projectName?.toLowerCase()) : projects[0];
   const wiPath = primaryProject ? shared.projectWorkItemsPath(primaryProject) : null;
   const workItems = wiPath ? (safeJson(wiPath) || []) : [];
 
@@ -176,7 +160,7 @@ function checkPlanCompletion(meta, config) {
         id, title: `Create PR for plan: ${plan.plan_summary || planFile}`,
         type: 'implement', priority: 'high',
         description: `All plan items from \`${planFile}\` are complete on branch \`${featureBranch}\`.\n\n**Branch:** \`${featureBranch}\`\n**Target:** \`${mainBranch}\`\n\n## Completed Items\n${itemSummary}`,
-        status: 'pending', created: ts(), createdBy: 'engine:plan-completion',
+        status: WI_STATUS.PENDING, created: ts(), createdBy: 'engine:plan-completion',
         sourcePlan: planFile, itemType: 'pr',
         branch: featureBranch, branchStrategy: 'shared-branch', project: projectName,
       });
@@ -206,12 +190,11 @@ function checkPlanCompletion(meta, config) {
 
     // Build per-project checkout commands: one worktree, merge all PR branches into it
     const checkoutBlocks = Object.entries(projectPrs).map(([name, { project: p, prs, mainBranch }]) => {
-      const localPath = p.localPath.replace(/\\/g, '/');
-      const wtPath = `${localPath}/../worktrees/verify-${name}-${planSlug}-${shared.uid()}`;
+      const wtPath = `${p.localPath}/../worktrees/verify-${name}-${planSlug}-${shared.uid()}`;
       const branches = prs.map(pr => pr.branch).filter(Boolean);
       const lines = [
         `# ${name} — merge ${branches.length} PR branch(es) into one worktree`,
-        `cd "${localPath}"`,
+        `cd "${p.localPath.replace(/\\/g, '/')}"`,
         `git fetch origin ${branches.map(b => `"${b}"`).join(' ')} "${mainBranch}"`,
         `git worktree add "${wtPath}" "origin/${mainBranch}" 2>/dev/null || (cd "${wtPath}" && git checkout "${mainBranch}" && git pull origin "${mainBranch}")`,
         `cd "${wtPath}"`,
@@ -232,10 +215,9 @@ function checkPlanCompletion(meta, config) {
     ).join('\n');
 
     // List projects and their worktree paths for the agent
-    const projectWorktrees = Object.entries(projectPrs).map(([name, { project: p }]) => {
-      const lp = p.localPath.replace(/\\/g, '/');
-      return `- **${name}**: see setup commands below (\`${lp}/../worktrees/verify-${name}-${planSlug}-*\`)`;
-    }).join('\n');
+    const projectWorktrees = Object.entries(projectPrs).map(([name, { project: p }]) =>
+      `- **${name}**: \`${p.localPath}/../worktrees/verify-${planSlug}\``
+    ).join('\n');
 
     const description = [
       `Verification task for completed plan \`${planFile}\`.`,
@@ -269,7 +251,7 @@ function checkPlanCompletion(meta, config) {
       type: 'verify',
       priority: 'high',
       description,
-      status: 'pending',
+      status: WI_STATUS.PENDING,
       created: ts(),
       createdBy: 'engine:plan-verification',
       sourcePlan: planFile,
@@ -280,75 +262,46 @@ function checkPlanCompletion(meta, config) {
     log('info', `Created verification work item ${verifyId} for plan ${planFile}`);
   }
 
-  // 5. Archive deferred until verify completes (see runPostCompletionHooks).
-  //    Plan stays active until verification finishes so artifacts are visible.
-
-  log('info', `PRD ${planFile} completed: ${doneItems.length} done, ${failedItems.length} failed, runtime ${runtimeMin}m`);
-}
-
-// ─── Plan Archiving (called after verify completes) ─────────────────────────
-
-function archivePlan(planFile, plan, projects, config) {
-  const planPath = path.join(PRD_DIR, planFile);
-  const projectName = plan.project || '';
-
-  // Archive PRD .json to prd/archive/
+  // 5. Archive: move PRD .json to prd/archive/ and source .md plan to plans/archive/
   const prdArchiveDir = path.join(PRD_DIR, 'archive');
   if (!fs.existsSync(prdArchiveDir)) fs.mkdirSync(prdArchiveDir, { recursive: true });
-  if (fs.existsSync(planPath)) {
+  shared.safeWrite(planPath, plan); // save completed status first
+  try {
+    fs.renameSync(planPath, path.join(prdArchiveDir, planFile));
+    log('info', `Archived completed PRD: prd/archive/${planFile}`);
+  } catch (err) {
+    log('warn', `Failed to archive PRD ${planFile}: ${err.message}`);
     shared.safeWrite(planPath, plan);
-    try {
-      fs.renameSync(planPath, path.join(prdArchiveDir, planFile));
-      log('info', `Archived completed PRD: prd/archive/${planFile}`);
-    } catch (err) { log('warn', `Failed to archive PRD ${planFile}: ${err.message}`); }
   }
 
-  // Archive the source .md plan
+  // Also archive the source .md plan if it exists
   const planArchiveDir = path.join(PLANS_DIR, 'archive');
   if (!fs.existsSync(planArchiveDir)) fs.mkdirSync(planArchiveDir, { recursive: true });
-  if (plan.source_plan) {
-    const mdPath = path.join(PLANS_DIR, plan.source_plan);
-    if (fs.existsSync(mdPath)) {
-      try {
-        fs.renameSync(mdPath, path.join(planArchiveDir, plan.source_plan));
-        log('info', `Archived source plan: plans/archive/${plan.source_plan}`);
-      } catch (err) { log('warn', `Failed to archive source plan ${plan.source_plan}: ${err.message}`); }
-    }
-  } else {
-    try {
-      const mdFiles = fs.readdirSync(PLANS_DIR).filter(f => f.endsWith('.md'));
-      for (const md of mdFiles) {
-        const mdContent = shared.safeRead(path.join(PLANS_DIR, md)) || '';
-        if (mdContent.includes(projectName) || mdContent.includes(plan.plan_summary?.slice(0, 40) || '___nomatch___')) {
-          try {
-            fs.renameSync(path.join(PLANS_DIR, md), path.join(planArchiveDir, md));
-            log('info', `Archived source plan: plans/archive/${md}`);
-          } catch (err) { log('warn', `Failed to archive plan ${md}: ${err.message}`); }
-          break;
-        }
-      }
-    } catch (err) { log('warn', `Plan archive scan: ${err.message}`); }
-  }
-
-  // Clean up ALL worktrees created for this plan's work items (shared-branch + per-item)
   try {
-    let allWi = [];
-    for (const p of projects) {
-      try { allWi = allWi.concat(safeJson(shared.projectWorkItemsPath(p)) || []); } catch {}
-    }
-    const planWi = allWi.filter(w => w.sourcePlan === planFile && w.itemType !== 'verify');
-    const allPrs = [];
-    for (const p of projects) {
-      try { allPrs.push(...(safeJson(shared.projectPrPath(p)) || [])); } catch {}
+    const mdFiles = fs.readdirSync(PLANS_DIR).filter(f => f.endsWith('.md'));
+    for (const md of mdFiles) {
+      const mdContent = shared.safeRead(path.join(PLANS_DIR, md)) || '';
+      // Match by project name or plan summary appearing in the .md content
+      if (mdContent.includes(projectName) || mdContent.includes(plan.plan_summary?.slice(0, 40) || '___nomatch___')) {
+        try {
+          fs.renameSync(path.join(PLANS_DIR, md), path.join(planArchiveDir, md));
+          log('info', `Archived source plan: plans/archive/${md}`);
+        } catch (err) { log('warn', `Failed to archive plan ${md}: ${err.message}`); }
+        break;
+      }
     }
+  } catch (err) { log('warn', `Plan archive scan: ${err.message}`); }
 
+  // 6. Clean up ALL worktrees created for this plan's work items (shared-branch + per-item)
+  try {
+    // Collect all branch slugs: shared-branch + per-item branches + item IDs
     const branchSlugs = new Set();
     if (plan.feature_branch) branchSlugs.add(shared.sanitizeBranch(plan.feature_branch).toLowerCase());
-    for (const w of planWi) {
+    for (const w of doneItems) {
       if (w.branch) branchSlugs.add(shared.sanitizeBranch(w.branch).toLowerCase());
       if (w.id) branchSlugs.add(w.id.toLowerCase());
     }
-    for (const pr of allPrs.filter(pr => (pr.prdItems || []).some(id => planWi.find(w => w.id === id)))) {
+    for (const pr of uniquePrs) {
       if (pr.branch) branchSlugs.add(shared.sanitizeBranch(pr.branch).toLowerCase());
     }
 
@@ -370,8 +323,10 @@ function archivePlan(planFile, plan, projects, config) {
         }
       }
     }
-    if (cleanedWt > 0) log('info', `Plan archive: cleaned ${cleanedWt} worktree(s)`);
+    if (cleanedWt > 0) log('info', `Plan completion: cleaned ${cleanedWt} worktree(s)`);
   } catch (err) { log('warn', `Worktree cleanup: ${err.message}`); }
+
+  log('info', `PRD ${planFile} completed: ${doneItems.length} done, ${failedItems.length} failed, runtime ${runtimeMin}m`);
 }
 
 // ─── Plan → PRD Chaining ─────────────────────────────────────────────────────
@@ -430,10 +385,6 @@ function chainPlanToPrd(dispatchItem, meta, config) {
 
   const projectName = meta?.item?.project || meta?.project?.name;
   const projects = shared.getProjects(config);
-  if (projects.length === 0) {
-    log('error', 'Plan chaining: no projects configured — cannot chain plan to PRD');
-    return;
-  }
   const targetProject = projectName
     ? projects.find(p => p.name === projectName) || projects[0]
     : projects[0];
@@ -446,17 +397,14 @@ function chainPlanToPrd(dispatchItem, meta, config) {
   log('info', `Plan chaining: queuing plan-to-prd for next tick (chained from ${dispatchItem.id})`);
   const wiPath = path.join(MINIONS_DIR, 'work-items.json');
   let items = [];
-  try { items = JSON.parse(fs.readFileSync(wiPath, 'utf8')); } catch (err) {
-    log('warn', `Failed to parse ${wiPath}: ${err.message} — creating .bak and starting fresh`);
-    try { fs.copyFileSync(wiPath, wiPath + '.bak'); } catch {}
-  }
+  try { items = JSON.parse(fs.readFileSync(wiPath, 'utf8')); } catch {}
   items.push({
     id: 'W-' + shared.uid(),
     title: `Convert plan to PRD: ${meta?.item?.title || planFile.name}`,
     type: 'plan-to-prd',
     priority: meta?.item?.priority || 'high',
     description: `Plan file: plans/${planFile.name}\nChained from plan task ${dispatchItem.id}`,
-    status: 'pending',
+    status: WI_STATUS.PENDING,
     created: ts(),
     createdBy: 'engine:chain',
     project: targetProject.name,
@@ -466,10 +414,15 @@ function chainPlanToPrd(dispatchItem, meta, config) {
 }
 
 // ─── Work Item Status ────────────────────────────────────────────────────────
+const _VALID_WI_STATUSES = new Set(Object.values(WI_STATUS));
 function updateWorkItemStatus(meta, status, reason) {
 
   const itemId = meta.item?.id;
   if (!itemId) return;
+  if (!_VALID_WI_STATUSES.has(status)) {
+    log('warn', `Invalid work item status '${status}' for ${itemId} — ignoring`);
+    return;
+  }
 
   let wiPath;
   if (meta.source === 'central-work-item' || meta.source === 'central-work-item-fanout') {
@@ -530,8 +483,10 @@ function updateWorkItemStatus(meta, status, reason) {
   }
 }
 
+const _VALID_PRD_STATUSES = new Set([...Object.values(WI_STATUS), 'missing']);
 function syncPrdItemStatus(itemId, status, sourcePlan) {
   if (!itemId) return;
+  if (!_VALID_PRD_STATUSES.has(status)) return;
   try {
     const prdDir = path.join(MINIONS_DIR, 'prd');
     const files = sourcePlan ? [sourcePlan] : require('fs').readdirSync(prdDir).filter(f => f.endsWith('.json'));
@@ -594,11 +549,7 @@ function syncPrsFromOutput(output, agentId, meta, config) {
   if (prMatches.size === 0) return 0;
 
   const projects = shared.getProjects(config);
-  if (projects.length === 0 && !meta?.project?.name) {
-    log('warn', `syncPrsFromOutput: no projects configured and no project in meta — cannot sync PRs`);
-    return 0;
-  }
-  const defaultProject = (meta?.project?.name && projects.find(p => p.name === meta.project.name)) || (projects[0] || null);
+  const defaultProject = (meta?.project?.name && projects.find(p => p.name === meta.project.name)) || projects[0];
   const useCentral = !defaultProject;
 
   // Match each PR to its correct project by finding which repo URL appears near the PR number in output
@@ -626,54 +577,47 @@ function syncPrsFromOutput(output, agentId, meta, config) {
   const agentName = config.agents?.[agentId]?.name || agentId;
   let added = 0;
   const centralPrPath = path.join(MINIONS_DIR, 'pull-requests.json');
+  // Track which PR files need writing — keyed by target name
+  const dirtyTargets = new Map(); // name -> { prs, prPath }
 
-  // Group PR matches by target file so we take one lock per target
-  const targetPrIds = new Map(); // targetName -> { prPath, prIds: [{ prId, fullId }] }
   for (const prId of prMatches) {
     const fullId = `PR-${prId}`;
     const targetProject = useCentral ? null : resolveProjectForPr(prId);
     const targetName = targetProject ? targetProject.name : '_central';
     const prPath = targetProject ? shared.projectPrPath(targetProject) : centralPrPath;
-    if (!targetPrIds.has(targetName)) {
-      targetPrIds.set(targetName, { prPath, prIds: [] });
+
+    // Load PRs for this target (cache per target)
+    if (!dirtyTargets.has(targetName)) {
+      dirtyTargets.set(targetName, { prs: safeJson(prPath) || [], prPath });
     }
-    targetPrIds.get(targetName).prIds.push({ prId, fullId });
+    const entry = dirtyTargets.get(targetName);
+    if (entry.prs.some(p => p.id === fullId || String(p.id).includes(prId))) continue;
+
+    let title = meta?.item?.title || '';
+    const titleMatch = output.match(new RegExp(`${prId}[^\\n]*?[—–-]\\s*([^\\n]+)`, 'i'));
+    if (titleMatch) title = titleMatch[1].trim();
+    if (title.includes('session_id') || title.includes('is_error') || title.includes('uuid') || title.length > 120) {
+      title = meta?.item?.title || '';
+    }
+    entry.prs.push({
+      id: fullId,
+      title: (title || `PR created by ${agentName}`).slice(0, 120),
+      agent: agentName,
+      branch: meta?.branch || '',
+      reviewStatus: 'pending',
+      status: PR_STATUS.ACTIVE,
+      created: dateStamp(),
+      url: extractPrUrl(prId),
+      prdItems: meta?.item?.id ? [meta.item.id] : [],
+      sourcePlan: meta?.item?.sourcePlan || '',
+      itemType: meta?.item?.itemType || ''
+    });
+    if (meta?.item?.id) addPrLink(fullId, meta.item.id);
+    added++;
   }
 
-  // For each target, read+modify+write inside a single locked callback
-  for (const [name, { prPath, prIds }] of targetPrIds) {
-    mutateJsonFileLocked(prPath, (prs) => {
-      if (!Array.isArray(prs)) prs = [];
-      // Deduplicate any existing entries with same id (case-insensitive agent name race)
-      const seen = new Set();
-      prs = prs.filter(p => { const k = String(p.id); if (seen.has(k)) return false; seen.add(k); return true; });
-      for (const { prId, fullId } of prIds) {
-        if (prs.some(p => p.id === fullId || String(p.id) === String(prId))) continue;
-
-        let title = meta?.item?.title || '';
-        const titleMatch = output.match(new RegExp(`${prId}[^\\n]*?[—–-]\\s*([^\\n]+)`, 'i'));
-        if (titleMatch) title = titleMatch[1].trim();
-        if (title.includes('session_id') || title.includes('is_error') || title.includes('uuid') || title.length > 120) {
-          title = meta?.item?.title || '';
-        }
-        prs.push({
-          id: fullId,
-          title: (title || `PR created by ${agentName}`).slice(0, 120),
-          agent: agentName,
-          branch: meta?.branch || '',
-          reviewStatus: 'pending',
-          status: 'active',
-          created: dateStamp(),
-          url: extractPrUrl(prId),
-          prdItems: meta?.item?.id ? [meta.item.id] : [],
-          sourcePlan: meta?.item?.sourcePlan || '',
-          itemType: meta?.item?.itemType || ''
-        });
-        if (meta?.item?.id) addPrLink(fullId, meta.item.id);
-        added++;
-      }
-      return prs;
-    }, { defaultValue: [] });
+  for (const [name, entry] of dirtyTargets) {
+    shared.safeWrite(entry.prPath, entry.prs);
     log('info', `Synced PR(s) from ${agentName}'s output to ${name === '_central' ? 'central' : name}/pull-requests.json`);
   }
   return added;
@@ -693,7 +637,7 @@ function updatePrAfterReview(agentId, pr, project) {
   // Record the reviewer — actual verdict comes from ADO/GitHub votes via pollPrStatus.
   // Set to 'waiting' so pollPrStatus updates it with the real vote on next cycle.
   const dispatch = getDispatch();
-  const completedEntry = (dispatch.completed || []).find(d => d.agent === agentId && d.type === WORK_TYPE.REVIEW);
+  const completedEntry = (dispatch.completed || []).find(d => d.agent === agentId && d.type === 'review');
 
   // Set reviewStatus to 'waiting' (single source of truth — synced from ADO/GitHub votes on next poll)
   target.reviewStatus = 'waiting';
@@ -718,7 +662,7 @@ function updatePrAfterReview(agentId, pr, project) {
   }
 
   shared.safeWrite(project ? shared.projectPrPath(project) : path.join(path.resolve(MINIONS_DIR, '..'), '.minions', 'pull-requests.json'), prs);
-  log('info', `Updated ${pr.id} → minions review: ${target.reviewStatus} by ${reviewerName}`);
+  log('info', `Updated ${pr.id} → minions review: ${minionsVerdict} by ${reviewerName}`);
   createReviewFeedbackForAuthor(agentId, { ...pr, ...target }, config);
 }
 
@@ -770,7 +714,7 @@ async function handlePostMerge(pr, project, config, newStatus) {
     } catch (err) { log('warn', `Post-merge worktree cleanup: ${err.message}`); }
   }
 
-  if (newStatus !== 'merged') return;
+  if (newStatus !== PR_STATUS.MERGED) return;
 
   // Resolve linked work item from pr-links or PR branch name
   let mergedItemId = getPrLinks()[pr.id];
@@ -894,12 +838,12 @@ function extractSkillsFromOutput(output, agentId, dispatchItem, config) {
       if (proj) {
         const centralPath = path.join(MINIONS_DIR, 'work-items.json');
         const items = safeJson(centralPath) || [];
-        const alreadyExists = items.some(i => i.title === `Add skill: ${name}` && i.status !== 'failed');
+        const alreadyExists = items.some(i => i.title === `Add skill: ${name}` && i.status !== WI_STATUS.FAILED);
         if (!alreadyExists) {
           const skillId = `SK${String(items.filter(i => i.id?.startsWith('SK')).length + 1).padStart(3, '0')}`;
           items.push({ id: skillId, type: 'implement', title: `Add skill: ${name}`,
             description: `Create project-level skill \`${filename}\` in ${project}.\n\nWrite this file to \`${proj.localPath}/.claude/skills/${filename}\` via a PR.\n\n## Skill Content\n\n\`\`\`\n${enrichedBlock}\n\`\`\``,
-            priority: 'low', status: 'queued', created: ts(), createdBy: `engine:skill-extraction:${agentName}` });
+            priority: 'low', status: WI_STATUS.QUEUED, created: ts(), createdBy: `engine:skill-extraction:${agentName}` });
           shared.safeWrite(centralPath, items);
           log('info', `Queued work item ${skillId} to PR project skill "${name}" into ${project}`);
         }
@@ -1084,7 +1028,7 @@ function handleDecompositionResult(stdout, meta, config) {
         type: (sub.estimated_complexity === 'large') ? 'implement:large' : 'implement',
         priority: sub.priority || parent.priority || 'medium',
         description: sub.description || '',
-        status: 'pending',
+        status: WI_STATUS.PENDING,
         complexity: sub.estimated_complexity || 'medium',
         depends_on: sub.depends_on || [],
         parent_id: parentId,
@@ -1124,13 +1068,13 @@ function runPostCompletionHooks(dispatchItem, agentId, code, stdout, config) {
 
   // Handle decomposition results — create sub-items from decompose agent output
   let skipDoneStatus = false;
-  if (type === 'decompose' && isSuccess && meta?.item?.id) {
+  if (type === WORK_TYPE.DECOMPOSE && isSuccess && meta?.item?.id) {
     const subCount = handleDecompositionResult(stdout, meta, config);
     if (subCount > 0) skipDoneStatus = true; // parent already marked 'decomposed' by handler
     // If decomposition produced nothing, fall through to mark parent as done
   }
 
-  if (isSuccess && meta?.item?.id && !skipDoneStatus) updateWorkItemStatus(meta, 'done', '');
+  if (isSuccess && meta?.item?.id && !skipDoneStatus) updateWorkItemStatus(meta, WI_STATUS.DONE, '');
   if (!isSuccess && meta?.item?.id) {
     // Auto-retry: read fresh _retryCount from file (not stale dispatch-time snapshot)
     let retries = (meta.item._retryCount || 0);
@@ -1145,9 +1089,8 @@ function runPostCompletionHooks(dispatchItem, agentId, code, stdout, config) {
       }
     } catch { /* optional */ }
 
-    const maxRetries = ENGINE_DEFAULTS.maxRetries;
-    if (retries < maxRetries) {
-      log('info', `Agent failed for ${meta.item.id} — auto-retry ${retries + 1}/${maxRetries}`);
+    if (retries < ENGINE_DEFAULTS.maxRetries) {
+      log('info', `Agent failed for ${meta.item.id} — auto-retry ${retries + 1}/${ENGINE_DEFAULTS.maxRetries}`);
       updateWorkItemStatus(meta, WI_STATUS.PENDING, '');
       try {
         const wiPath = meta.source === 'central-work-item' || meta.source === 'central-work-item-fanout'
@@ -1158,16 +1101,16 @@ function runPostCompletionHooks(dispatchItem, agentId, code, stdout, config) {
           const wi = items.find(i => i.id === meta.item.id);
           if (wi) {
             wi._retryCount = retries + 1; wi.status = WI_STATUS.PENDING; delete wi.dispatched_at; delete wi.dispatched_to;
-            if (type === WORK_TYPE.DECOMPOSE) delete wi._decomposing;
+            if (type === WORK_TYPE.DECOMPOSE) delete wi._decomposing; // clear so item can retry decomposition
             shared.safeWrite(wiPath, items);
           }
         }
       } catch (err) { log('warn', `Retry update: ${err.message}`); }
     } else {
-      updateWorkItemStatus(meta, WI_STATUS.FAILED, `Agent failed (${maxRetries} retries exhausted)`);
+      updateWorkItemStatus(meta, WI_STATUS.FAILED, `Agent failed (${ENGINE_DEFAULTS.maxRetries} retries exhausted)`);
     }
     // Clear _decomposing flag on failure so item doesn't get permanently stuck
-    if (type === 'decompose') {
+    if (type === WORK_TYPE.DECOMPOSE) {
       try {
         const wiPath = meta.source === 'central-work-item' || meta.source === 'central-work-item-fanout'
           ? path.join(MINIONS_DIR, 'work-items.json')
@@ -1181,7 +1124,7 @@ function runPostCompletionHooks(dispatchItem, agentId, code, stdout, config) {
     }
   }
   // Meeting post-completion: collect findings/debate/conclusion
-  if (type === 'meeting' && meta?.meetingId) {
+  if (type === WORK_TYPE.MEETING && meta?.meetingId) {
     try {
       const { collectMeetingFindings } = require('./meeting');
       collectMeetingFindings(meta.meetingId, agentId, meta.roundName, stdout);
@@ -1194,19 +1137,6 @@ function runPostCompletionHooks(dispatchItem, agentId, code, stdout, config) {
   let prsCreatedCount = 0;
   if (isSuccess) prsCreatedCount = syncPrsFromOutput(stdout, agentId, meta, config) || 0;
 
-  // Archive plan after verify task completes (AFTER PR sync so E2E PR is linked)
-  if (meta?.item?.itemType === 'verify' && meta?.item?.sourcePlan) {
-    try {
-      const vPlanFile = meta.item.sourcePlan;
-      const vPlanPath = path.join(PRD_DIR, vPlanFile);
-      const vPlan = safeJson(vPlanPath);
-      if (vPlan) {
-        const vProjects = shared.getProjects(config);
-        archivePlan(vPlanFile, vPlan, vProjects, config);
-      }
-    } catch (err) { log('warn', `Verify archive: ${err.message}`); }
-  }
-
   // Clean up worktree for non-shared-branch tasks after completion
   if (meta?.branch && meta?.branchStrategy !== 'shared-branch') {
     try {
@@ -1229,7 +1159,7 @@ function runPostCompletionHooks(dispatchItem, agentId, code, stdout, config) {
           for (const dir of dirs) {
             const wtPath = path.join(worktreeRoot, dir);
             try {
-              execSilent(`git worktree remove "${wtPath}" --force`, { cwd: rootDir, timeout: 15000 });
+              shared.exec(`git worktree remove "${wtPath}" --force`, { cwd: rootDir, stdio: 'pipe', timeout: 15000, windowsHide: true });
               log('info', `Post-completion: removed worktree ${dir}`);
             } catch (err) {
               log('warn', `Post-completion: failed to remove worktree ${dir}: ${err.message}`);
@@ -1263,16 +1193,15 @@ function runPostCompletionHooks(dispatchItem, agentId, code, stdout, config) {
           wi.noPr = true;
           wi.failReason = 'Completed without creating a pull request';
           const retries = wi._retryCount || 0;
-          const maxR = ENGINE_DEFAULTS.maxRetries;
-          if (retries < maxR) {
+          if (retries < ENGINE_DEFAULTS.maxRetries) {
             wi.status = WI_STATUS.PENDING;
             wi._retryCount = retries + 1;
             delete wi.dispatched_at;
             delete wi.dispatched_to;
-            log('info', `Auto-retry ${retries + 1}/${maxR} for ${meta.item.id} (no PR created)`);
+            log('info', `Auto-retry ${retries + 1}/${ENGINE_DEFAULTS.maxRetries} for ${meta.item.id} (no PR created)`);
           } else {
             wi.status = WI_STATUS.FAILED;
-            log('warn', `${meta.item.id} failed after ${maxR} retries — no PR created`);
+            log('warn', `${meta.item.id} failed after ${ENGINE_DEFAULTS.maxRetries} retries — no PR created`);
           }
           shared.safeWrite(wiPath, items);
         }
@@ -1286,7 +1215,7 @@ function runPostCompletionHooks(dispatchItem, agentId, code, stdout, config) {
   if (isSuccess) extractSkillsFromOutput(stdout, agentId, dispatchItem, config);
   updateAgentHistory(agentId, dispatchItem, result);
   // Don't count auto-retries as errors in metrics — only count final outcomes
-  const isAutoRetry = !isSuccess && meta?.item?.id && (meta.item._retryCount || 0) < 3;
+  const isAutoRetry = !isSuccess && meta?.item?.id && (meta.item._retryCount || 0) < ENGINE_DEFAULTS.maxRetries;
   const metricsResult = isAutoRetry ? 'retry' : result;
   updateMetrics(agentId, dispatchItem, metricsResult, taskUsage, prsCreatedCount, model);
 
@@ -1318,7 +1247,7 @@ function syncPrdFromPrs(config) {
         safeWrite(wiPath, items);
         // Sync done status to PRD JSON for each newly reconciled item
         for (const wi of items) {
-          if (wi.status === WI_STATUS.DONE) syncPrdItemStatus(wi.id, 'done', wi.sourcePlan);
+          if (wi.status === WI_STATUS.DONE) syncPrdItemStatus(wi.id, WI_STATUS.DONE, wi.sourcePlan);
         }
         totalReconciled += reconciled;
       }
@@ -1334,7 +1263,6 @@ function syncPrdFromPrs(config) {
 
 module.exports = {
   checkPlanCompletion,
-  archivePlan,
   updateWorkItemStatus,
   syncPrdItemStatus,
   syncPrsFromOutput,

package/engine/playbook.js

@@ -400,19 +400,19 @@ function buildAgentContext(agentId, config, project) {
   const projects = getProjects(config);
   const allPrs = [];
   for (const p of projects) {
-    const prs = getPrs(p).filter(pr => pr.status === PR_STATUS.ACTIVE || pr.status === 'linked');
+    const prs = getPrs(p).filter(pr => pr.status === PR_STATUS.ACTIVE);
     for (const pr of prs) allPrs.push({ ...pr, _project: p.name });
   }
   // Also check central pull-requests.json
   try {
     const centralPrs = safeJson(path.join(MINIONS_DIR, 'pull-requests.json')) || [];
-    for (const pr of centralPrs.filter(pr => pr.status === PR_STATUS.ACTIVE || pr.status === 'linked')) {
+    for (const pr of centralPrs.filter(pr => pr.status === PR_STATUS.ACTIVE)) {
       if (!allPrs.some(p => p.id === pr.id)) allPrs.push({ ...pr, _project: 'central' });
     }
   } catch (e) { log('warn', 'read central pull-requests: ' + e.message); }
   if (allPrs.length > 0) {
     const prLines = allPrs.map(pr =>
-      `- **${pr.id}** (${pr._project}): ${(pr.title || '').slice(0, 80)} [${pr.status === 'linked' ? 'context-only' : (pr.reviewStatus || 'pending')}${pr.buildStatus === 'failing' ? ', BUILD FAILING' : ''}]${pr.branch ? ' branch: `' + pr.branch + '`' : ''}${pr._context ? ' — ' + pr._context.slice(0, 100) : ''}`
+      `- **${pr.id}** (${pr._project}): ${(pr.title || '').slice(0, 80)} [${(pr.reviewStatus || 'pending')}${pr.buildStatus === 'failing' ? ', BUILD FAILING' : ''}]${pr.branch ? ' branch: `' + pr.branch + '`' : ''}${pr._context ? ' — ' + pr._context.slice(0, 100) : ''}`
     );
     context += `## Active Pull Requests\n\n${prLines.join('\n')}\n\n`;
   }

package/engine/queries.js

@@ -177,7 +177,7 @@ function getAgentStatus(agentId) {
     const latestInFlight = allItems
       .filter(w =>
         (w.dispatched_to || '').toLowerCase() === String(agentId).toLowerCase() &&
-        (w.status === 'dispatched' || w.status === 'in-progress')
+        w.status === 'dispatched'
       )
       .sort((a, b) => (b.dispatched_at || '').localeCompare(a.dispatched_at || ''))[0];
     if (latestInFlight) {
@@ -679,9 +679,9 @@ function getPrdInfo(config) {
   }
 
   // PRD JSON status is the source of truth — kept in sync with work item by syncPrdItemStatus.
-  // Map from PRD JSON values to display values (dispatched → in-progress etc.)
+  // Map from PRD JSON values to display values (pending → missing for undispatched items)
   // Augment each item with execution metadata from the work item.
-  const statusDisplay = { dispatched: 'in-progress', pending: 'missing' };
+  const statusDisplay = { pending: 'missing' };
   for (const item of items) {
     const wi = wiById[item.id];
     // Work item status is source of truth when available (PRD JSON may lag behind)
@@ -697,7 +697,7 @@ function getPrdInfo(config) {
   const byStatus = {};
   items.forEach(item => { const s = item.status || 'missing'; byStatus[s] = byStatus[s] || []; byStatus[s].push(item); });
   const complete = (byStatus['done'] || []).length;
-  const inProgress = (byStatus['in-progress'] || []).length;
+  const inProgress = (byStatus['dispatched'] || []).length;
   const paused = (byStatus['paused'] || []).length;
   const missing = (byStatus['missing'] || []).length;
   const donePercent = total > 0 ? Math.round((complete / total) * 100) : 0;

package/engine.js

@@ -25,7 +25,7 @@ const fs = require('fs');
 const path = require('path');
 const shared = require('./engine/shared');
 const { exec, execSilent, runFile, ENGINE_DEFAULTS: DEFAULTS,
-  WI_STATUS, DONE_STATUSES, WORK_TYPE, PLAN_STATUS, DISPATCH_RESULT } = shared;
+  WI_STATUS, DONE_STATUSES, WORK_TYPE, PLAN_STATUS, PR_STATUS, DISPATCH_RESULT } = shared;
 const queries = require('./engine/queries');
 
 // ─── Paths ──────────────────────────────────────────────────────────────────

package/package.json

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