@yemi33/minions 0.1.816 → 0.1.818

package/CHANGELOG.md

@@ -1,8 +1,12 @@
 # Changelog
 
-## 0.1.816 (2026-04-11)
+## 0.1.818 (2026-04-11)
 
 ### Features
+-  verify workflow handles shared-branch plans and existing E2E PRs
+-  doc-chat drag-to-resize, queued message UX, insertAdjacentHTML
+-  re-open done work items when PRD item set to updated/missing
+-  diff-aware plan-to-prd dispatch for completed/approved PRDs
 -  Bidirectional Teams integration for Command Center (#764)
 - show branch strategy on PRD view (#762)
 - Restructure decompose.md sub-task output format (#655)
@@ -13,6 +17,9 @@
 -  cap review→fix cycles at evalMaxIterations (default 3)
 
 ### Fixes
+-  strip ===ACTIONS=== from CC streamed text during rendering
+-  ccExecuteAction routes action status to correct tab via targetTabId
+-  clear _completionNotified on plan resume for re-completion
 - handle local-only dependency branches in dep merge (closes #782) (#825)
 - reset PRD item status when work item is deleted (closes #779) (#823)
 -  add smoke test for checkTimeouts ReferenceError regression (closes #775) (#822)
@@ -30,9 +37,9 @@
 -  approved is permanent — no path can ever downgrade it
 -  allow fix dispatch on approved PRs (only guard is in updatePrAfterFix)
 -  bot comment on approved PR can no longer reset vote
--  remove redundant 'PR' prefix from dispatch labels (id already has it)
--  include PR title in all dispatch labels and escalation alerts
--  never downgrade reviewStatus from 'approved' unless explicitly rejected
+
+### Other
+- docs: diff-aware PRD update playbook + prioritize team memory in shared rules
 
 ## 0.1.782 (2026-04-10)
 

package/dashboard/js/command-center.js

@@ -149,7 +149,10 @@ function ccSwitchTab(id) {
         html += '</div>';
       }
       var text = tab._streamedText || '';
-      if (text) html += renderMd(text);
+      if (text) {
+        var displayRestore = text.indexOf('===ACTIONS===') >= 0 ? text.slice(0, text.indexOf('===ACTIONS===')).trim() : text;
+        html += renderMd(displayRestore);
+      }
       var ms = Date.now() - restoreStart;
       var label = 'Thinking...';
       for (var pi = phases.length - 1; pi >= 0; pi--) { if (ms >= phases[pi][0]) { label = phases[pi][1]; break; } }
@@ -510,7 +513,8 @@ async function _ccDoSend(message, skipUserMsg) {
         html += '</div>';
       }
       if (streamedText) {
-        html += renderMd(streamedText);
+        var displayText = streamedText.indexOf('===ACTIONS===') >= 0 ? streamedText.slice(0, streamedText.indexOf('===ACTIONS===')).trim() : streamedText;
+        html += renderMd(displayText);
       }
       html += '<div style="margin-top:' + (streamedText ? '6px' : '0') + '">' + _getThinkingHtml() + '</div>';
       streamDiv.innerHTML = html;
@@ -579,7 +583,7 @@ async function _ccDoSend(message, skipUserMsg) {
               ccSaveState(); ccUpdateSessionIndicator();
             }
             if (evt.actions && evt.actions.length > 0) {
-              for (var ai = 0; ai < evt.actions.length; ai++) { await ccExecuteAction(evt.actions[ai]); }
+              for (var ai = 0; ai < evt.actions.length; ai++) { await ccExecuteAction(evt.actions[ai], activeTabId); }
             }
           } else if (evt.type === 'error') {
             _cleanupStreamDiv();
@@ -609,7 +613,7 @@ async function _ccDoSend(message, skipUserMsg) {
               ccSaveState(); ccUpdateSessionIndicator();
             }
             if (revt.actions && revt.actions.length > 0) {
-              for (var ai2 = 0; ai2 < revt.actions.length; ai2++) { await ccExecuteAction(revt.actions[ai2]); }
+              for (var ai2 = 0; ai2 < revt.actions.length; ai2++) { await ccExecuteAction(revt.actions[ai2], activeTabId); }
             }
           } else if (revt.type === 'chunk') {
             streamedText = revt.text;
@@ -688,8 +692,7 @@ async function _ccFetch(url, body) {
   return res;
 }
 
-async function ccExecuteAction(action) {
-  var msgs = document.getElementById('cc-messages');
+async function ccExecuteAction(action, targetTabId) {
   var status = document.createElement('div');
   status.style.cssText = 'padding:4px 10px;border-radius:4px;font-size:10px;align-self:flex-start;border:1px dashed var(--border);color:var(--muted)';
 
@@ -1052,8 +1055,7 @@ async function ccExecuteAction(action) {
     status.style.color = 'var(--red)';
   }
 
-  msgs.appendChild(status);
-  if (msgs.scrollHeight - msgs.scrollTop - msgs.clientHeight < 150) msgs.scrollTop = msgs.scrollHeight;
+  ccAddMessage('assistant', status.outerHTML, false, targetTabId);
   refresh();
 }
 

package/dashboard/js/modal-qa.js

@@ -28,6 +28,17 @@ let _qaAbortController = null;
 let _qaQueue = []; // queued messages while processing
 const QA_QUEUE_CAP = 10; // max queued messages
 let _qaSessionKey = ''; // key for current conversation (title or filePath)
+
+function _renderQaUserMessage(thread, message, selection) {
+  let qHtml = '<div class="modal-qa-q">' + escHtml(message);
+  if (selection) {
+    qHtml += '<span class="selection-ref">Re: "' + escHtml(selection.slice(0, 100)) + ((selection.length > 100) ? '...' : '') + '"</span>';
+  }
+  qHtml += '</div>';
+  thread.insertAdjacentHTML('beforeend', qHtml);
+  thread.scrollTop = thread.scrollHeight;
+  _showThreadWrap();
+}
 const _qaSessions = new Map(); // persist conversations across modal open/close {key → {history, threadHtml}}
 // Restore from localStorage
 try {
@@ -100,6 +111,11 @@ function _initQaSession() {
     }
     if (prior.filePath) _modalFilePath = prior.filePath;
     _showThreadWrap();
+    // Defer scroll — container just transitioned from display:none, layout not yet computed
+    requestAnimationFrame(function() {
+      var thread = document.getElementById('modal-qa-thread');
+      if (thread) thread.scrollTop = thread.scrollHeight;
+    });
   } else {
     _qaHistory = [];
     document.getElementById('modal-qa-thread').innerHTML = '';
@@ -145,16 +161,6 @@ function modalSend() {
   var thread = document.getElementById('modal-qa-thread');
   const selection = _modalDocContext.selection || '';
 
-  // Show message in thread immediately
-  let qHtml = '<div class="modal-qa-q">' + escHtml(message);
-  if (selection) {
-    qHtml += '<span class="selection-ref">Re: "' + escHtml(selection.slice(0, 100)) + ((selection.length > 100) ? '...' : '') + '"</span>';
-  }
-  qHtml += '</div>';
-  thread.innerHTML += qHtml;
-  thread.scrollTop = thread.scrollHeight;
-  _showThreadWrap();
-
   // Clear input immediately so user can type next message
   input.value = '';
   _modalDocContext.selection = '';
@@ -165,14 +171,18 @@ function modalSend() {
       showToast('cmd-toast', 'Queue full — wait for current response', false);
       return;
     }
-    // Queue the message — show it as "queued" in the thread
+    // Queue the message — show only grey queued indicator (blue bubble shows when processing starts)
     _qaQueue.push({ message, selection });
     const preview = escHtml(message.length > 60 ? message.slice(0, 57) + '...' : message);
-    thread.innerHTML += '<div class="qa-queued-item" style="color:var(--muted);font-size:10px;padding:4px 8px">Queued: "' + preview + '"</div>';
+    thread.insertAdjacentHTML('beforeend', '<div class="qa-queued-item" style="color:var(--muted);font-size:10px;padding:4px 8px">Queued: "' + preview + '"</div>');
     thread.scrollTop = thread.scrollHeight;
+    _showThreadWrap();
     return;
   }
 
+  // Show message in thread when processing starts (not when queued)
+  _renderQaUserMessage(thread, message, selection);
+
   _processQaMessage(message, selection);
 }
 
@@ -192,12 +202,12 @@ async function _processQaMessage(message, selection) {
   const loadingId = 'chat-loading-' + Date.now();
   const qaQueueBadge = _qaQueue.length > 0 ? ' <span style="font-size:9px;color:var(--muted);background:var(--surface);padding:1px 5px;border-radius:8px;border:1px solid var(--border)">+' + _qaQueue.length + ' queued</span>' : '';
   _qaAbortController = new AbortController();
-  thread.innerHTML += '<div class="modal-qa-loading" id="' + loadingId + '">' +
+  thread.insertAdjacentHTML('beforeend', '<div class="modal-qa-loading" id="' + loadingId + '">' +
     '<div class="dot-pulse"><span></span><span></span><span></span></div> ' +
     '<span id="' + loadingId + '-text">Thinking...</span> ' +
     '<span id="' + loadingId + '-time" style="font-size:10px;color:var(--muted)"></span>' +
     ' <button onclick="qaAbort()" style="font-size:9px;padding:2px 8px;background:var(--surface2);border:1px solid var(--border);border-radius:4px;color:var(--red);cursor:pointer">Stop</button>' +
-    qaQueueBadge + '</div>';
+    qaQueueBadge + '</div>');
   thread.scrollTop = thread.scrollHeight;
 
   const isPlanEdit = _modalFilePath && _modalFilePath.match(/^plans\/.*\.md$/);
@@ -237,7 +247,7 @@ async function _processQaMessage(message, selection) {
       const suffix = data.edited ? '\n\n\u2713 Document saved.' : '';
       const qaElapsed = Math.round((Date.now() - qaStartTime) / 1000);
       const qaTimeLabel = '<div style="font-size:9px;color:var(--muted);margin-top:4px;text-align:right;padding-right:24px">' + qaElapsed + 's</div>';
-      thread.innerHTML += '<div class="modal-qa-a" style="border-left-color:' + borderColor + '">' + llmCopyBtn() + renderMd(data.answer + suffix) + qaTimeLabel + '</div>';
+      thread.insertAdjacentHTML('beforeend', '<div class="modal-qa-a" style="border-left-color:' + borderColor + '">' + llmCopyBtn() + renderMd(data.answer + suffix) + qaTimeLabel + '</div>');
 
       // Track conversation history
       _qaHistory.push({ role: 'user', text: message });
@@ -281,7 +291,7 @@ async function _processQaMessage(message, selection) {
       }
     } else {
       const qaElapsedErr = Math.round((Date.now() - qaStartTime) / 1000);
-      thread.innerHTML += '<div class="modal-qa-a" style="color:var(--red)">Error: ' + escHtml(data.error || 'Failed') + '<div style="font-size:9px;color:var(--muted);margin-top:4px;text-align:right">' + qaElapsedErr + 's</div></div>';
+      thread.insertAdjacentHTML('beforeend', '<div class="modal-qa-a" style="color:var(--red)">Error: ' + escHtml(data.error || 'Failed') + '<div style="font-size:9px;color:var(--muted);margin-top:4px;text-align:right">' + qaElapsedErr + 's</div></div>');
     }
   } catch (e) {
     clearInterval(qaTimer);
@@ -289,9 +299,9 @@ async function _processQaMessage(message, selection) {
     if (loadingEl) loadingEl.remove();
     const qaElapsedExc = Math.round((Date.now() - qaStartTime) / 1000);
     if (e.name === 'AbortError') {
-      thread.innerHTML += '<div class="modal-qa-a" style="color:var(--muted)">Stopped<div style="font-size:9px;margin-top:4px;text-align:right">' + qaElapsedExc + 's</div></div>';
+      thread.insertAdjacentHTML('beforeend', '<div class="modal-qa-a" style="color:var(--muted)">Stopped<div style="font-size:9px;margin-top:4px;text-align:right">' + qaElapsedExc + 's</div></div>');
     } else {
-      thread.innerHTML += '<div class="modal-qa-a" style="color:var(--red)">Error: ' + escHtml(e.message) + '<div style="font-size:9px;color:var(--muted);margin-top:4px;text-align:right">' + qaElapsedExc + 's</div></div>';
+      thread.insertAdjacentHTML('beforeend', '<div class="modal-qa-a" style="color:var(--red)">Error: ' + escHtml(e.message) + '<div style="font-size:9px;color:var(--muted);margin-top:4px;text-align:right">' + qaElapsedExc + 's</div></div>');
     }
   }
 
@@ -329,9 +339,10 @@ async function _processQaMessage(message, selection) {
   // Process next queued message
   if (_qaQueue.length > 0) {
     const next = _qaQueue.shift();
-    // Remove the first queued indicator (matches the message being sent now)
+    // Remove the queued indicator and show the blue user bubble now that it's processing
     const queuedEl = thread.querySelector('.qa-queued-item');
     if (queuedEl) queuedEl.remove();
+    _renderQaUserMessage(thread, next.message, next.selection);
     _processQaMessage(next.message, next.selection);
   } else if (modalIsOpen) {
     document.getElementById('modal-qa-input')?.focus();
@@ -361,4 +372,46 @@ function _showThreadWrap() {
   if (expandBar) expandBar.style.display = 'none';
 }
 
+// ── Drag-to-resize doc chat thread ──────────────────────────────────────────
+(function() {
+  var _dragging = false, _startY = 0, _startH = 0, _thread = null;
+  var COLLAPSE_THRESHOLD = 40;
+  var MIN_HEIGHT = 60;
+  var MAX_HEIGHT = 500;
+
+  document.addEventListener('pointerdown', function(e) {
+    var handle = e.target.closest('#qa-resize-handle');
+    if (!handle) return;
+    _thread = document.getElementById('modal-qa-thread');
+    if (!_thread) return;
+    _dragging = true;
+    _startY = e.clientY;
+    _startH = _thread.offsetHeight || 200;
+    handle.setPointerCapture(e.pointerId);
+    document.body.style.userSelect = 'none';
+    e.preventDefault();
+  });
+
+  document.addEventListener('pointermove', function(e) {
+    if (!_dragging || !_thread) return;
+    var delta = _startY - e.clientY;
+    var newH = Math.max(MIN_HEIGHT, Math.min(MAX_HEIGHT, _startH + delta));
+    _thread.style.maxHeight = newH + 'px';
+  });
+
+  document.addEventListener('pointerup', function(e) {
+    if (!_dragging) return;
+    _dragging = false;
+    document.body.style.userSelect = '';
+    if (!_thread) return;
+    var delta = _startY - e.clientY;
+    var finalH = _startH + delta;
+    if (finalH < COLLAPSE_THRESHOLD) {
+      _thread.style.maxHeight = '';
+      toggleDocChat();
+    }
+    _thread = null;
+  });
+})();
+
 window.MinionsQA = { showModalQa, modalAskAboutSelection, clearQaSelection, clearQaConversation, modalSend, qaAbort, toggleDocChat, _showThreadWrap };

package/dashboard/layout.html

@@ -113,6 +113,9 @@
         <button style="background:none;border:none;color:var(--muted);font-size:10px;cursor:pointer;padding:2px 6px" onclick="toggleDocChat()" title="Expand thread">&#x25B2; Expand chat</button>
       </div>
       <div id="modal-qa-thread-wrap" style="display:none">
+        <div id="qa-resize-handle" style="height:6px;cursor:ns-resize;display:flex;align-items:center;justify-content:center;user-select:none;touch-action:none" title="Drag to resize">
+          <div style="width:32px;height:3px;border-radius:2px;background:var(--border)"></div>
+        </div>
         <div style="display:flex;align-items:center;justify-content:space-between;margin-bottom:4px">
           <button id="qa-clear-btn" style="background:none;border:none;color:var(--muted);font-size:10px;cursor:pointer;padding:2px 6px" onclick="clearQaConversation()" title="Clear conversation">Clear</button>
           <button style="background:none;border:none;color:var(--muted);font-size:10px;cursor:pointer;padding:2px 6px" onclick="toggleDocChat()" id="qa-toggle-btn" title="Collapse thread">&#x25BC; Collapse</button>

package/dashboard.js

@@ -2186,6 +2186,7 @@ If nothing to do: { "duplicates": [], "reclassify": [], "remove": [] }`;
       plan.approvedAt = new Date().toISOString();
       plan.approvedBy = body.approvedBy || os.userInfo().username;
       delete plan.pausedAt;
+      delete plan._completionNotified; // Allow re-completion after new work finishes
       safeWrite(planPath, plan);
 
       // Resume paused work items across all projects

package/engine/lifecycle.js

@@ -204,8 +204,22 @@ function checkPlanCompletion(meta, config) {
       }
     }
 
+    // Shared-branch plans already have all changes on a single feature branch — no merge needed
+    const isSharedBranch = plan.branch_strategy === 'shared-branch' && plan.feature_branch;
+
     // Build per-project checkout commands: one worktree, merge all PR branches into it
     const checkoutBlocks = Object.entries(projectPrs).map(([name, { project: p, prs, mainBranch }]) => {
+      if (isSharedBranch) {
+        const featureBranch = plan.feature_branch;
+        const wtPath = `${p.localPath}/../worktrees/verify-${name}-${planSlug}`;
+        const lines = [
+          `# ${name} — shared-branch: use existing feature branch directly`,
+          `cd "${p.localPath.replace(/\\/g, '/')}"`,
+          `git fetch origin "${featureBranch}"`,
+          `git worktree add "${wtPath}" "origin/${featureBranch}" 2>/dev/null || (cd "${wtPath}" && git checkout "${featureBranch}" && git pull origin "${featureBranch}")`,
+        ];
+        return lines.join('\n');
+      }
       const wtPath = `${p.localPath}/../worktrees/verify-${name}-${planSlug}-${shared.uid()}`;
       const branches = prs.map(pr => pr.branch).filter(Boolean);
       const lines = [
@@ -235,9 +249,13 @@ function checkPlanCompletion(meta, config) {
       `- **${name}**: \`${p.localPath}/../worktrees/verify-${planSlug}\``
     ).join('\n');
 
+    const sharedBranchNote = isSharedBranch
+      ? `\n**Shared-branch plan** — all changes are already on branch \`${plan.feature_branch}\`. Use this branch directly for the E2E PR instead of creating a new \`e2e/\` branch. Check if a PR already exists for this branch before creating one.\n`
+      : '';
+
     const description = [
       `Verification task for completed plan \`${planFile}\`.`,
-      ``,
+      sharedBranchNote,
       `## Projects & Worktrees`,
       ``,
       `Each project gets ONE worktree with all PR branches merged in:`,

package/engine.js

@@ -1227,6 +1227,12 @@ function autoCleanPrdWorkItems(prdFile, config) {
   }
 }
 
+function buildWiDescription(item, planFile) {
+  const criteria = (item.acceptance_criteria || []).map(c => `- ${c}`).join('\n');
+  const complexity = item.estimated_complexity || 'medium';
+  return `${item.description || ''}\n\n**Plan:** ${planFile}\n**Plan Item:** ${item.id}\n**Complexity:** ${complexity}${criteria ? '\n\n**Acceptance Criteria:**\n' + criteria : ''}`;
+}
+
 function materializePlansAsWorkItems(config) {
   if (!fs.existsSync(PRD_DIR)) { try { fs.mkdirSync(PRD_DIR, { recursive: true }); } catch (e) { log('warn', 'create PRD directory: ' + e.message); } }
 
@@ -1325,19 +1331,72 @@ function materializePlansAsWorkItems(config) {
           // Handle PRD based on current status
           const prdStatus = plan.status || (plan.requires_approval ? 'awaiting-approval' : null);
 
-          // Approved/paused/completed PRDs: flag stale — user must click Re-execute to regenerate
-          if (prdStatus && prdStatus !== 'awaiting-approval') {
+          // Approved/completed PRDs with existing work: auto-dispatch diff-aware plan-to-prd update
+          if (prdStatus === PLAN_STATUS.APPROVED || prdStatus === PLAN_STATUS.COMPLETED) {
+            const allWorkItems = queries.getWorkItems(config);
+            const planWis = allWorkItems.filter(w => w.sourcePlan === file && w.itemType !== 'pr' && w.itemType !== 'verify');
+            const doneWis = planWis.filter(w => DONE_STATUSES.has(w.status));
+            if (doneWis.length > 0) {
+              const allPrs = getProjects(config).flatMap(p => safeJson(projectPrPath(p)) || []);
+              const prLinks = shared.getPrLinks();
+              const implContext = (plan.missing_features || []).map(f => {
+                const wi = planWis.find(w => w.id === f.id);
+                const pr = allPrs.find(p => prLinks[p.id] === f.id || (p.prdItems || []).includes(f.id));
+                return `- **${f.id}**: ${f.name} [status: ${wi?.status || f.status}]${pr ? ` (PR: ${pr.id}, branch: \`${pr.branch}\`)` : ''}`;
+              }).join('\n');
+
+              const planContent = safeRead(path.join(PLANS_DIR, plan.source_plan));
+              if (planContent) {
+                const projectName = plan.project || file.replace(/-\d{4}-\d{2}-\d{2}\.json$/, '');
+                const allProjects = getProjects(config);
+                const targetProject = allProjects.find(p => p.name?.toLowerCase() === projectName.toLowerCase()) || allProjects[0];
+                if (targetProject) {
+                  const centralWiPath = path.join(MINIONS_DIR, 'work-items.json');
+                  let queued = false;
+                  mutateJsonFileLocked(centralWiPath, items => {
+                    if (!Array.isArray(items)) items = [];
+                    if (items.some(w => w.type === WORK_TYPE.PLAN_TO_PRD && w.planFile === plan.source_plan && (w.status === WI_STATUS.PENDING || w.status === WI_STATUS.DISPATCHED))) return items;
+                    items.push({
+                      id: 'W-' + shared.uid(),
+                      title: `Update PRD from revised plan: ${plan.source_plan}`,
+                      type: 'plan-to-prd',
+                      priority: 'high',
+                      description: `Plan file: plans/${plan.source_plan}\nPRD file: prd/${file}\n\n` +
+                        `Source plan was revised. Compare the updated plan against existing implementation and update the PRD.\n\n` +
+                        `**Existing implementation state:**\n${implContext}\n\n` +
+                        `**Rules for updating:**\n` +
+                        `- Items that are done and unchanged in the plan → keep status "done" (preserve their ID)\n` +
+                        `- Items that are done but modified in the plan (new requirements) → set status "updated" (engine will re-open)\n` +
+                        `- New items in the plan → set status "missing" (engine will materialize)\n` +
+                        `- Items removed from the plan → drop from PRD (engine will cancel pending WIs)\n` +
+                        `- Preserve all existing item IDs for unchanged/modified items — do NOT generate new IDs for them`,
+                      status: 'pending',
+                      created: ts(),
+                      createdBy: 'engine:plan-revision',
+                      project: targetProject.name,
+                      planFile: plan.source_plan,
+                      _existingPrdFile: file,
+                    });
+                    queued = true;
+                    return items;
+                  }, { defaultValue: [] });
+                  if (queued) log('info', `Queued diff-aware plan-to-prd update for ${plan.source_plan} (${doneWis.length} done, ${planWis.length} total items)`);
+                }
+              }
+            } else {
+              plan.planStale = true;
+              log('info', `PRD ${file} flagged as stale (plan revised while ${prdStatus}, no done items) — user can re-execute from dashboard`);
+            }
+          } else if (prdStatus === PLAN_STATUS.PAUSED) {
             plan.planStale = true;
-            log('info', `PRD ${file} flagged as stale (plan revised while ${prdStatus}) — user can re-execute from dashboard`);
-            // Falls through to safeWrite below (writes planStale + sourcePlanModifiedAt together)
+            log('info', `PRD ${file} flagged as stale (plan revised while paused) — user can re-execute from dashboard`);
           }
 
           // Awaiting-approval PRDs: auto-regenerate (no work started yet, safe to replace)
           if (prdStatus === 'awaiting-approval') {
             log('info', `PRD ${file} invalidated (was awaiting-approval) — queuing regeneration from revised plan`);
 
-            // Collect completed items to carry over to new PRD
-            const completedStatuses = new Set(['done', 'in-pr', 'implemented']); // in-pr kept for backward compat
+            const completedStatuses = new Set(['done', 'in-pr', 'implemented']);
             const completedItems = (plan.missing_features || [])
               .filter(f => completedStatuses.has(f.status))
               .map(f => ({ id: f.id, name: f.name, status: f.status }));
@@ -1346,10 +1405,8 @@ function materializePlansAsWorkItems(config) {
               ? `\nPreviously completed items (preserve their status in the new PRD):\n${completedItems.map(i => `- ${i.id}: ${i.name} [${i.status}]`).join('\n')}`
               : '';
 
-            // Delete old PRD — agent will write replacement at same path
             try { fs.unlinkSync(path.join(PRD_DIR, file)); } catch { /* cleanup */ }
 
-            // Queue plan-to-prd regeneration
             const planContent = safeRead(path.join(PLANS_DIR, plan.source_plan));
             if (planContent) {
               const projectName = plan.project || file.replace(/-\d{4}-\d{2}-\d{2}\.json$/, '');
@@ -1357,12 +1414,11 @@ function materializePlansAsWorkItems(config) {
               const targetProject = allProjects.find(p => p.name?.toLowerCase() === projectName.toLowerCase()) || allProjects[0];
               if (targetProject) {
                 const centralWiPath = path.join(MINIONS_DIR, 'work-items.json');
-                const centralItems = safeJson(centralWiPath) || [];
-                const alreadyQueued = centralItems.some(w =>
-                  w.type === WORK_TYPE.PLAN_TO_PRD && w.planFile === plan.source_plan && (w.status === WI_STATUS.PENDING || w.status === WI_STATUS.DISPATCHED)
-                );
-                if (!alreadyQueued) {
-                  centralItems.push({
+                let queued = false;
+                mutateJsonFileLocked(centralWiPath, items => {
+                  if (!Array.isArray(items)) items = [];
+                  if (items.some(w => w.type === WORK_TYPE.PLAN_TO_PRD && w.planFile === plan.source_plan && (w.status === WI_STATUS.PENDING || w.status === WI_STATUS.DISPATCHED))) return items;
+                  items.push({
                     id: 'W-' + shared.uid(),
                     title: `Regenerate PRD from revised plan: ${plan.source_plan}`,
                     type: 'plan-to-prd',
@@ -1374,9 +1430,10 @@ function materializePlansAsWorkItems(config) {
                     project: targetProject.name,
                     planFile: plan.source_plan,
                   });
-                  safeWrite(centralWiPath, centralItems);
-                  log('info', `Queued plan-to-prd regeneration for revised plan ${plan.source_plan} (${completedItems.length} completed items to carry over)`);
-                }
+                  queued = true;
+                  return items;
+                }, { defaultValue: [] });
+                if (queued) log('info', `Queued plan-to-prd regeneration for revised plan ${plan.source_plan} (${completedItems.length} completed items to carry over)`);
               }
             }
             continue; // Old PRD deleted — skip safeWrite below
@@ -1415,7 +1472,7 @@ function materializePlansAsWorkItems(config) {
     // No project found — use central work-items.json (engine works without projects)
     const useCentral = !defaultProject;
 
-    const statusFilter = ['missing', 'planned'];
+    const statusFilter = ['missing', 'planned', 'updated'];
     // Also materialize in-pr/done items that never got a work item (race with PR status sync)
     const allExistingWiIds = new Set();
     for (const w of queries.getWorkItems()) {
@@ -1466,32 +1523,53 @@ function materializePlansAsWorkItems(config) {
       const wiPath = project ? projectWorkItemsPath(project) : path.join(MINIONS_DIR, 'work-items.json');
       let created = 0;
       const newlyCreatedIds = new Set(); // tracks IDs created in this pass for reconciliation scoping
+      const deferredReopens = []; // cross-project re-opens executed after this lock releases
 
       mutateWorkItems(wiPath, existingItems => {
         for (const item of projItems) {
+          // Re-open: PRD item set back to missing/planned/updated but work item is done → reset to pending
+          const existingWi = existingItems.find(w => w.id === item.id);
+          const shouldReopen = item.status === 'missing' || item.status === 'planned' || item.status === 'updated';
+          if (existingWi && DONE_STATUSES.has(existingWi.status) && shouldReopen) {
+            existingWi.status = WI_STATUS.PENDING;
+            existingWi._reopened = true;
+            const criteria = (item.acceptance_criteria || []).map(c => `- ${c}`).join('\n');
+            existingWi.description = buildWiDescription(item, file);
+            existingWi.title = `Implement: ${item.name}`;
+            created++;
+            log('info', `Re-opened work item ${item.id} (PRD item set back to ${item.status}) — will dispatch to existing branch`);
+            continue;
+          }
+
           // Skip if already materialized — work item ID = PRD item ID, check all projects
-          let alreadyExists = existingItems.some(w => w.id === item.id);
+          let alreadyExists = !!existingWi;
           if (!alreadyExists) {
             for (const p of allProjects) {
               if (p.name === projName) continue;
               const otherItems = safeJson(projectWorkItemsPath(p)) || [];
-              if (otherItems.some(w => w.id === item.id)) { alreadyExists = true; break; }
+              const otherWi = otherItems.find(w => w.id === item.id);
+              if (otherWi) {
+                if (DONE_STATUSES.has(otherWi.status) && shouldReopen) {
+                  deferredReopens.push({ itemId: item.id, projectName: p.name, item });
+                  created++;
+                }
+                alreadyExists = true; break;
+              }
             }
           }
           if (alreadyExists) continue;
           // Skip items involved in dependency cycles
           if (cycleSet.has(item.id)) continue;
 
-          const id = item.id; // Work item ID = PRD item ID — no indirection
+          const id = item.id;
           const complexity = item.estimated_complexity || 'medium';
-          const criteria = (item.acceptance_criteria || []).map(c => `- ${c}`).join('\n');
 
           const newItem = {
             id,
             title: `Implement: ${item.name}`,
             type: complexity === 'large' ? 'implement:large' : 'implement',
             priority: item.priority || 'medium',
-            description: `${item.description || ''}\n\n**Plan:** ${file}\n**Plan Item:** ${item.id}\n**Complexity:** ${complexity}${criteria ? '\n\n**Acceptance Criteria:**\n' + criteria : ''}`,
+            description: buildWiDescription(item, file),
             status: 'pending',
             created: ts(),
             createdBy: 'engine:plan-discovery',
@@ -1530,6 +1608,24 @@ function materializePlansAsWorkItems(config) {
           log('info', `Plan discovery: created ${created} work item(s) from ${file} → ${projName}`);
         }
       });
+
+      // Process cross-project re-opens outside the lock (no nested locks)
+      for (const { itemId, projectName: rProjName, item: rItem } of deferredReopens) {
+        const rProject = allProjects.find(p => p.name === rProjName);
+        if (!rProject) continue;
+        const rPath = projectWorkItemsPath(rProject);
+        mutateWorkItems(rPath, items => {
+          const target = items.find(w => w.id === itemId);
+          if (target && DONE_STATUSES.has(target.status)) {
+            target.status = WI_STATUS.PENDING;
+            target._reopened = true;
+            target.description = buildWiDescription(rItem, file);
+            target.title = `Implement: ${rItem.name}`;
+          }
+        });
+        log('info', `Re-opened work item ${itemId} in ${rProjName} (cross-project, PRD item set to ${rItem.status})`);
+      }
+
       totalCreated += created;
     }
 

package/package.json

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

package/playbooks/plan-to-prd.md

@@ -91,6 +91,20 @@ Rules for items:
 - Include `acceptance_criteria` so reviewers know when it's done
 - Aim for 5-25 items depending on plan scope. If more than 25, group related work
 
+## Updating an Existing PRD
+
+If the task description mentions **"existing implementation state"**, you are updating an existing PRD, not creating one from scratch. The plan was revised and you need to produce an updated PRD that reflects the changes while preserving existing work.
+
+**Rules for diff-aware updates:**
+- **Read the existing PRD file first** — it's at `{{team_root}}/prd/{{prd_filename}}`
+- **Preserve item IDs** — do NOT generate new IDs for items that already exist. The engine maps work items by ID.
+- **Done + unchanged** → keep `"status": "done"` and the same ID (no work dispatched)
+- **Done + modified** (plan added requirements/scope) → set `"status": "updated"` with same ID (engine re-opens the work item and dispatches to existing branch)
+- **New items** in the updated plan → generate new `P-<uuid>` IDs, set `"status": "missing"`
+- **Removed items** (in old PRD but not in updated plan) → drop from the PRD entirely (engine cancels pending work items)
+- **Pending/failed items** → reset to `"missing"` with updated description
+- Preserve `branch_strategy`, `feature_branch`, `project`, and other plan-level fields from the existing PRD unless the plan explicitly changes them
+
 ## Important
 
 - Write ONLY the single `.json` PRD file to `{{team_root}}/prd/` — do NOT write any `.md` files there

package/playbooks/shared-rules.md

@@ -10,14 +10,14 @@ Your context window may be compacted or summarized mid-task by Claude's automati
 - Do NOT remove worktrees — the engine handles cleanup automatically.
 - Do NOT checkout branches in the main working tree — use worktrees or `git diff`/`git show`.
 - Read `notes.md` for team rules and decisions before starting.
-- **Check minions state before starting fresh.** Before researching from scratch, check what the team already knows:
-  - `notes.md` — consolidated team knowledge, decisions, and context
-  - `knowledge/` — categorized KB entries (architecture, conventions, build-reports, reviews)
-  - `notes/inbox/` — recent agent findings not yet consolidated
-  - Previous agent output in `agents/*/live-output.log` for related tasks
-  - Work item descriptions and `resultSummary` for prior completed work on the same topic
-  - `pinned.md` — critical context flagged by the human teammate
-  This avoids duplicating research another agent already completed.
+- **Check team memory first, then look outside.** Before researching from scratch, check what the team already knows — in this order:
+  1. `pinned.md` — critical context flagged by the human teammate (READ FIRST)
+  2. `knowledge/` — categorized KB entries (architecture, conventions, build-reports, reviews)
+  3. `notes.md` — consolidated team knowledge, decisions, and context
+  4. `notes/inbox/` — recent agent findings not yet consolidated
+  5. Previous agent output in `agents/*/live-output.log` for related tasks
+  6. Work item descriptions and `resultSummary` for prior completed work on the same topic
+  Only after exhausting team memory should you look outside (web search, codebase exploration, external docs). This avoids duplicating research another agent already completed and ensures team decisions are respected.
 - If you discover a repeatable workflow, output it as a fenced skill block. The engine auto-extracts it to `~/.claude/skills/<name>/SKILL.md`. Required format:
   ````
   ```skill

package/playbooks/verify.md

@@ -92,30 +92,39 @@ For each project that has changes, create a single **aggregate PR** that combine
 
 For each project worktree:
 
-1. Push the combined branch:
+1. **Check for an existing E2E branch/PR first** — a prior verify run may have already created one:
    ```bash
    cd <worktree-path>
-   git checkout -b e2e/{{plan_slug}}
-   git push origin e2e/{{plan_slug}}
+   git fetch origin
+   # Check if the E2E branch already exists on remote
+   git ls-remote --heads origin e2e/{{plan_slug}}
    ```
-
-2. Create a PR targeting the project's main branch using `mcp__azure-ado__repo_create_pull_request` (or `gh pr create` for GitHub):
-   - **Title:** `[E2E] <plan summary>`
-   - **Description:** Include:
-     - The plan summary
-     - List of all individual PRs merged into this branch
-     - Build/test status from Step 3
-     - Link to the testing guide
-   - **Target branch:** the project's main branch (e.g., `main` or `master`)
-   - **Do NOT auto-complete** — this is for review only
-   - **Mark as draft** if the option is available
-
-3. Add the E2E PR to the project's `.minions/pull-requests.json`:
+   - If the branch **already exists**: check out the existing branch (`git checkout e2e/{{plan_slug}}`), reset it to your current worktree state, and force-push to update it. Then check if a PR already exists for this branch — if so, **update that PR** instead of creating a new one.
+   - If the branch **does not exist**: create it fresh:
+     ```bash
+     git checkout -b e2e/{{plan_slug}}
+     git push origin e2e/{{plan_slug}}
+     ```
+
+2. **Check for an existing E2E PR** before creating a new one:
+   - For GitHub: `gh pr list --head e2e/{{plan_slug}} --state open`
+   - For ADO: search for PRs with source branch `e2e/{{plan_slug}}`
+   - If found, **update the existing PR** description with latest build/test results. Do NOT create a duplicate.
+   - If not found, create a new PR targeting the project's main branch:
+     - **Title:** `[E2E] <plan summary>`
+     - **Description:** Include the plan summary, list of all individual PRs merged, build/test status from Step 3, and link to the testing guide
+     - **Target branch:** the project's main branch (e.g., `main` or `master`)
+     - **Do NOT auto-complete** — this is for review only
+     - **Mark as draft** if the option is available
+
+3. Add the E2E PR to the project's `.minions/pull-requests.json` (skip if it's already tracked):
    ```bash
    node -e "
    const fs = require('fs');
    const p = '<project-path>/.minions/pull-requests.json';
    const prs = JSON.parse(fs.readFileSync(p, 'utf8'));
+   // Skip if already tracked
+   if (prs.some(pr => pr.branch === 'e2e/{{plan_slug}}')) process.exit(0);
    prs.push({
      id: 'PR-<number>',
      title: '[E2E] <plan summary>',