@yemi33/minions 0.1.328 → 0.1.330

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.1.330 (2026-04-03)
+
+### Fixes
+-  resolve all 25 lifecycle.js test failures
+-  remove orphan statuses, add validation, replace in-progress with dispatched
+
 ## 0.1.328 (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

@@ -5,9 +5,11 @@
 
 const fs = require('fs');
 const path = require('path');
+const os = require('os');
 const shared = require('./shared');
-const { safeRead, safeJson, safeWrite, execSilent, projectPrPath, getPrLinks, addPrLink,
-  log, ts, dateStamp } = shared;
+const { safeRead, safeJson, safeWrite, mutateJsonFileLocked, execSilent, projectPrPath, getPrLinks, addPrLink,
+  log, ts, dateStamp, WI_STATUS, DONE_STATUSES, WORK_TYPE, PLAN_STATUS, PR_STATUS, DISPATCH_RESULT,
+  ENGINE_DEFAULTS } = shared;
 const { trackEngineUsage } = require('./llm');
 const queries = require('./queries');
 const { getConfig, getInboxFiles, getNotes, getPrs, getDispatch,
@@ -21,7 +23,9 @@ function checkPlanCompletion(meta, config) {
   const planPath = path.join(PRD_DIR, planFile);
   const plan = safeJson(planPath);
   if (!plan?.missing_features) return;
-  if (plan.status === 'completed') return;
+  if (plan.status === PLAN_STATUS.COMPLETED) {
+    if (plan._completionNotified) return;
+  }
 
   const projects = shared.getProjects(config);
 
@@ -53,7 +57,7 @@ function checkPlanCompletion(meta, config) {
   const unmaterialized = [...planFeatureIds].filter(id => {
     if (workItemById[id]) return false;
     const prdItem = (plan.missing_features || []).find(f => f.id === id);
-    return !(prdItem && (prdItem.status === 'done' || prdItem.status === 'in-pr'));
+    return !(prdItem && DONE_STATUSES.has(prdItem.status));
   });
   if (unmaterialized.length > 0) {
     log('info', `Plan ${planFile}: ${unmaterialized.length}/${planFeatureIds.size} feature(s) not yet materialized as work items: ${unmaterialized.join(', ')}`);
@@ -63,20 +67,20 @@ function checkPlanCompletion(meta, config) {
   // Check 2: every feature's work item must be done (or PRD item marked done externally)
   const notDone = [...planFeatureIds].filter(id => {
     const w = workItemById[id];
-    if (w && (w.status === 'done' || w.status === 'in-pr')) return false; // in-pr accepted for backward compat
+    if (w && DONE_STATUSES.has(w.status)) return false;
     const prdItem = (plan.missing_features || []).find(f => f.id === id);
-    return !(prdItem && (prdItem.status === 'done' || prdItem.status === 'in-pr'));
+    return !(prdItem && DONE_STATUSES.has(prdItem.status));
   });
   if (notDone.length > 0) {
     log('info', `Plan ${planFile}: waiting for done on ${notDone.length}/${planFeatureIds.size} item(s): ${notDone.join(', ')}`);
     return;
   }
 
-  const doneItems = planItems.filter(w => w.status === 'done' || w.status === 'in-pr');
-  const failedItems = planItems.filter(w => w.status === 'failed');
+  const doneItems = planItems.filter(w => DONE_STATUSES.has(w.status));
+  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
@@ -133,16 +137,28 @@ function checkPlanCompletion(meta, config) {
   ].filter(Boolean).join('\n');
 
   // 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}`);
+  const summarySlug = `prd-completion-${planFile.replace('.json', '')}`;
+  shared.writeToInbox('engine', summarySlug, summary);
+  log('info', `PRD completion summary written to notes/inbox/${summarySlug}`);
+
+  // Persist completed status + _completionNotified via file lock
+  mutateJsonFileLocked(planPath, (data) => {
+    data.status = PLAN_STATUS.COMPLETED;
+    data.completedAt = plan.completedAt;
+    data._completionNotified = true;
+    return data;
+  });
 
   // 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];
-  const wiPath = primaryProject ? shared.projectWorkItemsPath(primaryProject) : null;
-  const workItems = wiPath ? (safeJson(wiPath) || []) : [];
+  if (!primaryProject) {
+    log('warn', `Plan ${planFile}: no primary project found — skipping PR/verify creation`);
+    return;
+  }
+  const wiPath = shared.projectWorkItemsPath(primaryProject);
+  const workItems = safeJson(wiPath) || [];
 
   // 3. For shared-branch plans, create PR work item
   if (plan.branch_strategy === 'shared-branch' && plan.feature_branch && wiPath) {
@@ -156,7 +172,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,
       });
@@ -177,7 +193,7 @@ function checkPlanCompletion(meta, config) {
       const prs = (safeJson(shared.projectPrPath(p)) || [])
         .filter(pr => {
           const linkedId = prLinks[pr.id];
-          return pr.status === 'active' && linkedId && doneItems.find(w => w.id === linkedId);
+          return pr.status === PR_STATUS.ACTIVE && linkedId && doneItems.find(w => w.id === linkedId);
         });
       if (prs.length > 0) {
         projectPrs[p.name] = { project: p, prs, mainBranch: p.mainBranch || 'main' };
@@ -190,7 +206,7 @@ function checkPlanCompletion(meta, config) {
       const branches = prs.map(pr => pr.branch).filter(Boolean);
       const lines = [
         `# ${name} — merge ${branches.length} PR branch(es) into one worktree`,
-        `cd "${p.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}"`,
@@ -247,7 +263,7 @@ function checkPlanCompletion(meta, config) {
       type: 'verify',
       priority: 'high',
       description,
-      status: 'pending',
+      status: WI_STATUS.PENDING,
       created: ts(),
       createdBy: 'engine:plan-verification',
       sourcePlan: planFile,
@@ -258,47 +274,94 @@ function checkPlanCompletion(meta, config) {
     log('info', `Created verification work item ${verifyId} for plan ${planFile}`);
   }
 
-  // 5. Archive: move PRD .json to prd/archive/ and source .md plan to plans/archive/
+  // Archive deferred until verify completes
+
+  log('info', `PRD ${planFile} completed: ${doneItems.length} done, ${failedItems.length} failed, runtime ${runtimeMin}m`);
+}
+
+// ─── Archive Plan ───────────────────────────────────────────────────────────
+function archivePlan(planFile, plan, projects, config) {
+  const planPath = path.join(PRD_DIR, planFile);
+
+  // Archive PRD .json to prd/archive/
   const prdArchiveDir = path.join(PRD_DIR, 'archive');
   if (!fs.existsSync(prdArchiveDir)) fs.mkdirSync(prdArchiveDir, { recursive: true });
-  shared.safeWrite(planPath, plan); // save completed status first
   try {
-    fs.renameSync(planPath, path.join(prdArchiveDir, planFile));
-    log('info', `Archived completed PRD: prd/archive/${planFile}`);
+    if (fs.existsSync(planPath)) {
+      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);
   }
 
-  // Also archive the source .md plan if it exists
+  // Archive the source .md plan if it exists
+  const projectName = plan.project;
   const planArchiveDir = path.join(PLANS_DIR, 'archive');
   if (!fs.existsSync(planArchiveDir)) fs.mkdirSync(planArchiveDir, { recursive: true });
   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)) || '';
-      // 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;
+    // Direct match by source_plan field or planFile-derived name
+    const sourcePlanName = plan.source_plan || planFile.replace(/\.json$/, '.md');
+    if (sourcePlanName && fs.existsSync(path.join(PLANS_DIR, sourcePlanName))) {
+      try {
+        fs.renameSync(path.join(PLANS_DIR, sourcePlanName), path.join(planArchiveDir, sourcePlanName));
+        log('info', `Archived source plan: plans/archive/${sourcePlanName}`);
+      } catch (err) { log('warn', `Failed to archive plan ${sourcePlanName}: ${err.message}`); }
+    } else {
+      // Fallback: match by content
+      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}`); }
 
-  // 6. Clean up ALL worktrees created for this plan's work items (shared-branch + per-item)
+  // 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());
+
+    // Collect work items for this plan
+    let allWorkItems = [];
+    for (const p of projects) {
+      try {
+        const wi = safeJson(shared.projectWorkItemsPath(p)) || [];
+        allWorkItems = allWorkItems.concat(wi);
+      } catch { /* optional */ }
+    }
+    try {
+      const central = safeJson(path.join(MINIONS_DIR, 'work-items.json')) || [];
+      for (const w of central) {
+        if (!allWorkItems.some(existing => existing.id === w.id)) allWorkItems.push(w);
+      }
+    } catch { /* optional */ }
+    const planItems = allWorkItems.filter(w => w.sourcePlan === planFile);
+    const doneItems = planItems.filter(w => DONE_STATUSES.has(w.status));
+
     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 uniquePrs) {
-      if (pr.branch) branchSlugs.add(shared.sanitizeBranch(pr.branch).toLowerCase());
+
+    // Collect PR branches
+    for (const p of projects) {
+      try {
+        const prs = safeJson(shared.projectPrPath(p)) || [];
+        const prLinks = getPrLinks();
+        for (const pr of prs) {
+          const linkedId = prLinks[pr.id];
+          if (linkedId && doneItems.find(w => w.id === linkedId) && pr.branch) {
+            branchSlugs.add(shared.sanitizeBranch(pr.branch).toLowerCase());
+          }
+        }
+      } catch { /* optional */ }
     }
 
     let cleanedWt = 0;
@@ -319,10 +382,8 @@ function checkPlanCompletion(meta, config) {
         }
       }
     }
-    if (cleanedWt > 0) log('info', `Plan completion: cleaned ${cleanedWt} worktree(s)`);
+    if (cleanedWt > 0) log('info', `Archive: 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 ─────────────────────────────────────────────────────
@@ -381,6 +442,10 @@ 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');
+    return;
+  }
   const targetProject = projectName
     ? projects.find(p => p.name === projectName) || projects[0]
     : projects[0];
@@ -393,14 +458,17 @@ 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 {}
+  try { items = JSON.parse(fs.readFileSync(wiPath, 'utf8')); } catch (err) {
+    log('warn', `Failed to parse ${wiPath}: ${err.message}`);
+    try { fs.copyFileSync(wiPath, wiPath + '.bak'); } 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,
@@ -410,10 +478,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') {
@@ -435,20 +508,20 @@ function updateWorkItemStatus(meta, status, reason) {
       target.agentResults[agent] = { status, completedAt: ts(), reason: reason || undefined };
 
       const results = Object.values(target.agentResults);
-      const anySuccess = results.some(r => r.status === 'done');
+      const anySuccess = results.some(r => r.status === WI_STATUS.DONE);
       const allDone = Array.isArray(target.fanOutAgents) && target.fanOutAgents.length > 0 ? results.length >= target.fanOutAgents.length : false;
       const dispatchAge = target.dispatched_at ? Date.now() - new Date(target.dispatched_at).getTime() : 0;
       const timedOut = !allDone && dispatchAge > 6 * 60 * 60 * 1000 && results.length > 0;
 
       if (anySuccess) {
-        target.status = 'done';
+        target.status = WI_STATUS.DONE;
         delete target.failReason;
         delete target.failedAt;
         target.completedAgents = Object.entries(target.agentResults)
-          .filter(([, r]) => r.status === 'done')
+          .filter(([, r]) => r.status === WI_STATUS.DONE)
           .map(([a]) => a);
       } else if (allDone || timedOut) {
-        target.status = 'failed';
+        target.status = WI_STATUS.FAILED;
         target.failReason = timedOut
           ? `Fan-out timed out: ${results.length}/${(target.fanOutAgents || []).length} agents reported (all failed)`
           : 'All fan-out agents failed';
@@ -456,11 +529,11 @@ function updateWorkItemStatus(meta, status, reason) {
       }
     } else {
       target.status = status;
-      if (status === 'done') {
+      if (status === WI_STATUS.DONE) {
         delete target.failReason;
         delete target.failedAt;
         target.completedAt = ts();
-      } else if (status === 'failed') {
+      } else if (status === WI_STATUS.FAILED) {
         if (reason) target.failReason = reason;
         target.failedAt = ts();
       }
@@ -474,8 +547,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'));
@@ -538,6 +613,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) return 0;
   const defaultProject = (meta?.project?.name && projects.find(p => p.name === meta.project.name)) || projects[0];
   const useCentral = !defaultProject;
 
@@ -566,8 +642,9 @@ 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 new PRs by target file path
+  const newPrsByPath = new Map(); // prPath -> [{ prId, newEntry }]
 
   for (const prId of prMatches) {
     const fullId = `PR-${prId}`;
@@ -575,38 +652,43 @@ function syncPrsFromOutput(output, agentId, meta, config) {
     const targetName = targetProject ? targetProject.name : '_central';
     const prPath = targetProject ? shared.projectPrPath(targetProject) : centralPrPath;
 
-    // Load PRs for this target (cache per target)
-    if (!dirtyTargets.has(targetName)) {
-      dirtyTargets.set(targetName, { prs: safeJson(prPath) || [], prPath });
-    }
-    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: 'active',
-      created: dateStamp(),
-      url: extractPrUrl(prId),
-      prdItems: meta?.item?.id ? [meta.item.id] : [],
-      sourcePlan: meta?.item?.sourcePlan || '',
-      itemType: meta?.item?.itemType || ''
+
+    if (!newPrsByPath.has(prPath)) newPrsByPath.set(prPath, { name: targetName, entries: [] });
+    newPrsByPath.get(prPath).entries.push({
+      prId, fullId,
+      entry: {
+        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 (const [name, entry] of dirtyTargets) {
-    shared.safeWrite(entry.prPath, entry.prs);
+  for (const [prPath, { name, entries }] of newPrsByPath) {
+    mutateJsonFileLocked(prPath, (data) => {
+      const prs = Array.isArray(data) ? data : [];
+      for (const { prId, fullId, entry } of entries) {
+        if (prs.some(p => p.id === fullId || String(p.id) === String(prId))) continue;
+        prs.push(entry);
+        if (meta?.item?.id) addPrLink(fullId, meta.item.id);
+        added++;
+      }
+      return prs;
+    });
     log('info', `Synced PR(s) from ${agentName}'s output to ${name === '_central' ? 'central' : name}/pull-requests.json`);
   }
   return added;
@@ -651,7 +733,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: ${minionsVerdict} by ${reviewerName}`);
+  log('info', `Updated ${pr.id} → minions review: ${target.reviewStatus} by ${reviewerName}`);
   createReviewFeedbackForAuthor(agentId, { ...pr, ...target }, config);
 }
 
@@ -703,7 +785,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];
@@ -722,13 +804,13 @@ async function handlePostMerge(pr, project, config, newStatus) {
         const plan = safeJson(path.join(prdDir, pf));
         if (!plan?.missing_features) continue;
         const feature = plan.missing_features.find(f => f.id === mergedItemId);
-        if (feature && feature.status !== 'implemented') {
-          feature.status = 'implemented';
+        if (feature && feature.status !== WI_STATUS.DONE) {
+          feature.status = WI_STATUS.DONE;
           shared.safeWrite(path.join(prdDir, pf), plan);
           updated++;
         }
       }
-      if (updated > 0) log('info', `Post-merge: marked ${mergedItemId} as implemented for ${pr.id}`);
+      if (updated > 0) log('info', `Post-merge: marked ${mergedItemId} as done for ${pr.id}`);
     } catch (err) { log('warn', `Post-merge PRD update: ${err.message}`); }
 
     // Mark work item as done
@@ -739,10 +821,10 @@ async function handlePostMerge(pr, project, config, newStatus) {
         const items = safeJson(wiPath);
         if (!items) continue;
         const item = items.find(i => i.id === mergedItemId);
-        if (item && item.status !== 'done') {
+        if (item && item.status !== WI_STATUS.DONE) {
           log('info', `Post-merge: marking work item ${mergedItemId} as done (was ${item.status}) for ${pr.id}`);
-          item.status = 'done';
-          item.completedAt = e.ts();
+          item.status = WI_STATUS.DONE;
+          item.completedAt = ts();
           item._mergedVia = pr.id;
           shared.safeWrite(wiPath, items);
           break;
@@ -827,19 +909,19 @@ 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}`);
         }
       }
     } else {
       // Write in Claude Code native format: ~/.claude/skills/<name>/SKILL.md
-      const claudeSkillsDir = path.join(process.env.HOME || process.env.USERPROFILE || '', '.claude', 'skills');
+      const claudeSkillsDir = path.join(os.homedir(), '.claude', 'skills');
       const skillDir = path.join(claudeSkillsDir, name.replace(/[^a-z0-9-]/g, '-'));
       const skillPath = path.join(skillDir, 'SKILL.md');
       if (!fs.existsSync(skillPath)) {
@@ -918,10 +1000,10 @@ function updateMetrics(agentId, dispatchItem, result, taskUsage, prsCreatedCount
   m.lastTask = dispatchItem.task;
   m.lastCompleted = ts();
   if (model) m.model = model;
-  if (result === 'success') {
+  if (result === DISPATCH_RESULT.SUCCESS) {
     m.tasksCompleted++;
     if (prsCreatedCount > 0) m.prsCreated = (m.prsCreated || 0) + prsCreatedCount;
-    if (dispatchItem.type === 'review') m.reviewsDone++;
+    if (dispatchItem.type === WORK_TYPE.REVIEW) m.reviewsDone++;
   } else if (result === 'retry') {
     // Auto-retry: count cost but not as a final outcome
     m.tasksRetried = (m.tasksRetried || 0) + 1;
@@ -1003,7 +1085,7 @@ function handleDecompositionResult(stdout, meta, config) {
     if (!parent) continue;
 
     // Mark parent as decomposed
-    parent.status = 'decomposed';
+    parent.status = WI_STATUS.DECOMPOSED;
     parent._decomposed = true;
     delete parent._decomposing;
     parent._subItemIds = subItems.map(s => s.id);
@@ -1017,7 +1099,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,
@@ -1042,7 +1124,7 @@ function runPostCompletionHooks(dispatchItem, agentId, code, stdout, config) {
   const type = dispatchItem.type;
   const meta = dispatchItem.meta;
   const isSuccess = code === 0;
-  const result = isSuccess ? 'success' : 'error';
+  const result = isSuccess ? DISPATCH_RESULT.SUCCESS : DISPATCH_RESULT.ERROR;
   const { resultSummary, taskUsage, sessionId, model } = parseAgentOutput(stdout);
 
   // Save session for potential resume on next dispatch
@@ -1057,13 +1139,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);
@@ -1078,9 +1160,9 @@ function runPostCompletionHooks(dispatchItem, agentId, code, stdout, config) {
       }
     } catch { /* optional */ }
 
-    if (retries < 3) {
-      log('info', `Agent failed for ${meta.item.id} — auto-retry ${retries + 1}/3`);
-      updateWorkItemStatus(meta, 'pending', '');
+    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'
           ? path.join(MINIONS_DIR, 'work-items.json')
@@ -1089,17 +1171,17 @@ function runPostCompletionHooks(dispatchItem, agentId, code, stdout, config) {
           const items = safeJson(wiPath) || [];
           const wi = items.find(i => i.id === meta.item.id);
           if (wi) {
-            wi._retryCount = retries + 1; wi.status = 'pending'; delete wi.dispatched_at; delete wi.dispatched_to;
-            if (type === 'decompose') delete wi._decomposing; // clear so item can retry decomposition
+            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; // clear so item can retry decomposition
             shared.safeWrite(wiPath, items);
           }
         }
       } catch (err) { log('warn', `Retry update: ${err.message}`); }
     } else {
-      updateWorkItemStatus(meta, 'failed', 'Agent failed (3 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')
@@ -1113,7 +1195,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);
@@ -1126,6 +1208,19 @@ function runPostCompletionHooks(dispatchItem, agentId, code, stdout, config) {
   let prsCreatedCount = 0;
   if (isSuccess) prsCreatedCount = syncPrsFromOutput(stdout, agentId, meta, config) || 0;
 
+  // After verify completes, archive the plan
+  if (isSuccess && 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 {
@@ -1140,7 +1235,7 @@ function runPostCompletionHooks(dispatchItem, agentId, code, stdout, config) {
           return d.includes(branchSlug) && fs.statSync(path.join(worktreeRoot, d)).isDirectory();
         });
         // Only remove if no other active dispatch uses this branch
-        const dispatch = e.getDispatch();
+        const dispatch = getDispatch();
         const otherActive = ((dispatch.active || []).concat(dispatch.pending || [])).some(d =>
           d.id !== dispatchItem.id && d.meta?.branch && shared.sanitizeBranch && shared.sanitizeBranch(d.meta.branch) === branchSlug
         );
@@ -1162,7 +1257,7 @@ function runPostCompletionHooks(dispatchItem, agentId, code, stdout, config) {
   }
 
   // Detect implement tasks that completed without creating a PR
-  if (isSuccess && (type === 'implement' || type === 'implement:large' || type === 'fix') && prsCreatedCount === 0 && meta?.item?.id) {
+  if (isSuccess && (type === WORK_TYPE.IMPLEMENT || type === WORK_TYPE.IMPLEMENT_LARGE || type === WORK_TYPE.FIX) && prsCreatedCount === 0 && meta?.item?.id) {
     // Check if a PR already exists linked to this work item (from a previous attempt)
     const projects = shared.getProjects(config);
     const existingPrFound = Object.values(getPrLinks()).includes(meta.item.id);
@@ -1182,15 +1277,15 @@ function runPostCompletionHooks(dispatchItem, agentId, code, stdout, config) {
           wi.noPr = true;
           wi.failReason = 'Completed without creating a pull request';
           const retries = wi._retryCount || 0;
-          if (retries < 3) {
-            wi.status = 'pending';
+          if (retries < ENGINE_DEFAULTS.maxRetries) {
+            wi.status = WI_STATUS.PENDING;
             wi._retryCount = retries + 1;
             delete wi.dispatched_at;
             delete wi.dispatched_to;
-            e.log('info', `Auto-retry ${retries + 1}/3 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 = 'failed';
-            e.log('warn', `${meta.item.id} failed after 3 retries — no PR created`);
+            wi.status = WI_STATUS.FAILED;
+            log('warn', `${meta.item.id} failed after ${ENGINE_DEFAULTS.maxRetries} retries — no PR created`);
           }
           shared.safeWrite(wiPath, items);
         }
@@ -1198,13 +1293,13 @@ function runPostCompletionHooks(dispatchItem, agentId, code, stdout, config) {
     }
   }
 
-  if (type === 'review') updatePrAfterReview(agentId, meta?.pr, meta?.project);
-  if (type === 'fix') updatePrAfterFix(meta?.pr, meta?.project, meta?.source);
+  if (type === WORK_TYPE.REVIEW) updatePrAfterReview(agentId, meta?.pr, meta?.project);
+  if (type === WORK_TYPE.FIX) updatePrAfterFix(meta?.pr, meta?.project, meta?.source);
   checkForLearnings(agentId, config.agents[agentId], dispatchItem.task);
   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);
 
@@ -1229,14 +1324,14 @@ function syncPrdFromPrs(config) {
     for (const project of allProjects) {
       const wiPath = projectWorkItemsPath(project);
       const items = safeJson(wiPath) || [];
-      const hasPending = items.some(wi => wi.status === 'pending' && !wi._pr);
+      const hasPending = items.some(wi => wi.status === WI_STATUS.PENDING && !wi._pr);
       if (!hasPending) continue;
       const reconciled = reconcileItemsWithPrs(items, allPrs);
       if (reconciled > 0) {
         safeWrite(wiPath, items);
         // Sync done status to PRD JSON for each newly reconciled item
         for (const wi of items) {
-          if (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;
       }
@@ -1252,6 +1347,7 @@ 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/package.json

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