@yemi33/minions 0.1.888 → 0.1.890

package/CHANGELOG.md

@@ -1,11 +1,14 @@
 # Changelog
 
-## 0.1.888 (2026-04-11)
+## 0.1.890 (2026-04-11)
 
 ### Features
 -  add 13 missing CC action types for full dashboard parity
 
 ### Fixes
+- parse review verdict from agent output for GitHub self-approval (#912) (#918)
+- verify PRD file exists before marking plan-to-prd done (#893) (#911)
+- re-open done work items when PRD item reset to missing (#906) (#910)
 - require explicit vote step in review playbook
 -  CC queued message silently retries on 429 after abort
 - track e2e/ and fix/ branches in PR reconciler

package/engine/lifecycle.js

@@ -779,6 +779,27 @@ function syncPrsFromOutput(output, agentId, meta, config) {
 
 // ─── Post-Completion Hooks ──────────────────────────────────────────────────
 
+/**
+ * Parse review verdict from agent output text.
+ * Looks for "VERDICT: APPROVE" or "VERDICT: REQUEST_CHANGES" markers that the
+ * review playbook instructs agents to include. This is the primary mechanism for
+ * GitHub repos where formal --approve/--request-changes votes are blocked by
+ * self-approval restrictions.
+ * @param {string} text - Agent output / resultSummary
+ * @returns {'approved'|'changes-requested'|null}
+ */
+function parseReviewVerdict(text) {
+  if (!text) return null;
+  // Match "VERDICT: APPROVE" or "VERDICT: REQUEST_CHANGES" (case-insensitive, optional markdown bold)
+  const verdictMatch = text.match(/VERDICT[:\s]+\*{0,2}(APPROVE|REQUEST[_\s-]?CHANGES)\*{0,2}/i);
+  if (verdictMatch) {
+    const v = verdictMatch[1].toUpperCase().replace(/[\s-]/g, '_');
+    if (v === 'APPROVE') return 'approved';
+    if (v.includes('CHANGES')) return 'changes-requested';
+  }
+  return null;
+}
+
 async function updatePrAfterReview(agentId, pr, project, config, resultSummary) {
 
   if (!pr?.id) return;
@@ -804,6 +825,15 @@ async function updatePrAfterReview(agentId, pr, project, config, resultSummary)
     }
   } catch (e) { log('warn', `Post-review status check for ${pr.id}: ${e.message}`); }
 
+  // Fallback: if live check returned pending (e.g., GitHub self-approval blocked), parse verdict from agent output
+  if (!postReviewStatus) {
+    const verdict = parseReviewVerdict(resultSummary);
+    if (verdict) {
+      postReviewStatus = verdict;
+      log('info', `Parsed review verdict from agent output for ${pr.id}: ${verdict}`);
+    }
+  }
+
   const prPath = project ? shared.projectPrPath(project) : path.join(path.resolve(MINIONS_DIR, '..'), '.minions', 'pull-requests.json');
   let updatedTarget = null;
   shared.mutateJsonFileLocked(prPath, (prs) => {
@@ -839,7 +869,7 @@ async function updatePrAfterReview(agentId, pr, project, config, resultSummary)
     }, { defaultValue: {} });
   }
 
-  log('info', `Updated ${pr.id} → minions review: waiting by ${reviewerName}`);
+  log('info', `Updated ${pr.id} → minions review: ${postReviewStatus || 'waiting'} by ${reviewerName}`);
   if (updatedTarget) createReviewFeedbackForAuthor(agentId, updatedTarget, config);
 }
 
@@ -1499,6 +1529,54 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
     // If decomposition produced nothing, fall through to mark parent as done
   }
 
+  // Verify plan-to-prd actually created the PRD file before marking done (#893)
+  // Must run BEFORE updateWorkItemStatus(DONE) — otherwise _retryCount is deleted and retries never advance
+  if (effectiveSuccess && type === WORK_TYPE.PLAN_TO_PRD && meta?.item?.id) {
+    let prdFound = false;
+    const expectedFile = meta.item._prdFilename;
+    if (expectedFile) {
+      prdFound = fs.existsSync(path.join(PRD_DIR, expectedFile));
+    }
+    if (!prdFound && meta.item.planFile) {
+      try {
+        for (const f of fs.readdirSync(PRD_DIR)) {
+          if (!f.endsWith('.json')) continue;
+          try {
+            const prd = safeJson(path.join(PRD_DIR, f));
+            if (prd && prd.source_plan === meta.item.planFile) { prdFound = true; break; }
+          } catch {}
+        }
+      } catch {}
+    }
+    if (!prdFound) {
+      skipDoneStatus = true;
+      const wiPath = resolveWorkItemPath(meta);
+      if (wiPath) {
+        try {
+          mutateJsonFileLocked(wiPath, data => {
+            if (!Array.isArray(data)) return data;
+            const w = data.find(i => i.id === meta.item.id);
+            if (!w) return data;
+            const retries = w._retryCount || 0;
+            if (retries < ENGINE_DEFAULTS.maxRetries) {
+              w.status = WI_STATUS.PENDING;
+              w._retryCount = retries + 1;
+              delete w.dispatched_at;
+              delete w.completedAt;
+              log('warn', `plan-to-prd ${meta.item.id} completed without PRD file — auto-retry ${retries + 1}/${ENGINE_DEFAULTS.maxRetries}`);
+            } else {
+              w.status = WI_STATUS.FAILED;
+              w.failReason = 'PRD file not written after ' + ENGINE_DEFAULTS.maxRetries + ' attempts';
+              w.failedAt = ts();
+              log('warn', `plan-to-prd ${meta.item.id} failed — no PRD file after ${ENGINE_DEFAULTS.maxRetries} retries`);
+            }
+            return data;
+          });
+        } catch (err) { log('warn', `plan-to-prd PRD check: ${err.message}`); }
+      }
+    }
+  }
+
   if (effectiveSuccess && meta?.item?.id && !skipDoneStatus) {
     meta._agentId = agentId;
     updateWorkItemStatus(meta, WI_STATUS.DONE, '');
@@ -1622,26 +1700,15 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
     }
   }
 
-  // Detect plan-to-prd tasks that completed without creating a PRD file
-  if (effectiveSuccess && type === WORK_TYPE.PLAN_TO_PRD && meta?.item?.planFile) {
-    // Check by stored filename first (deterministic), fall back to source_plan scan
-    let prdFound = false;
-    const expectedFile = meta.item._prdFilename;
-    if (expectedFile) {
-      prdFound = fs.existsSync(path.join(PRD_DIR, expectedFile));
-    }
-    if (!prdFound) {
-      try {
-        for (const f of fs.readdirSync(PRD_DIR)) {
-          if (!f.endsWith('.json')) continue;
-          try {
-            const prd = safeJson(path.join(PRD_DIR, f));
-            if (prd && prd.source_plan === meta.item.planFile) { prdFound = true; break; }
-          } catch {}
-        }
-      } catch {}
-    }
-    if (!prdFound) {
+  // Old plan-to-prd PRD check removed — moved before updateWorkItemStatus(DONE) to fix #893
+  // (retryCount was being deleted by done-marking before the check could read it)
+
+  // Verify review work items include a verdict — mirrors the PRD file existence check pattern.
+  // If agent completed (exit 0) but output has no VERDICT: APPROVE/REQUEST_CHANGES, the review
+  // is incomplete. Auto-retry up to maxRetries, then fail.
+  if (effectiveSuccess && type === WORK_TYPE.REVIEW && meta?.item?.id) {
+    const verdict = parseReviewVerdict(resultSummary);
+    if (!verdict) {
       const wiPath = resolveWorkItemPath(meta);
       if (wiPath) {
         mutateJsonFileLocked(wiPath, data => {
@@ -1653,11 +1720,11 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
             w.status = WI_STATUS.PENDING;
             w._retryCount = retries + 1;
             delete w.dispatched_at;
-            log('warn', `plan-to-prd ${meta.item.id} completed without PRD file — auto-retry ${retries + 1}/${ENGINE_DEFAULTS.maxRetries}`);
+            log('warn', `Review ${meta.item.id} completed without verdict — auto-retry ${retries + 1}/${ENGINE_DEFAULTS.maxRetries}`);
           } else {
             w.status = WI_STATUS.FAILED;
-            w.failReason = 'Completed without creating PRD file after ' + ENGINE_DEFAULTS.maxRetries + ' attempts';
-            log('warn', `plan-to-prd ${meta.item.id} failed — no PRD file after ${ENGINE_DEFAULTS.maxRetries} retries`);
+            w.failReason = 'No review verdict after ' + ENGINE_DEFAULTS.maxRetries + ' attempts';
+            log('warn', `Review ${meta.item.id} failed — no verdict after ${ENGINE_DEFAULTS.maxRetries} retries`);
           }
           return data;
         });
@@ -1819,6 +1886,7 @@ module.exports = {
   createReviewFeedbackForAuthor,
   updateMetrics,
   parseAgentOutput,
+  parseReviewVerdict,
   parseStructuredCompletion,
   runPostCompletionHooks,
   syncPrdFromPrs,

package/engine/playbook.js

@@ -81,13 +81,14 @@ function getPrVoteInstructions(project) {
   if (host === 'github') {
     const org = project?.adoOrg || '';
     const repo = project?.repoName || '';
-    return `Use \`gh pr review\` to submit a review on the PR:\n` +
-      `- Approve: \`gh pr review <number> --approve --body "Approval comment" --repo ${org}/${repo}\`\n` +
-      `- Request changes: \`gh pr review <number> --request-changes --body "What needs to change" --repo ${org}/${repo}\`\n` +
-      `- Comment only: \`gh pr review <number> --comment --body "Review comment" --repo ${org}/${repo}\`\n` +
+    return `**IMPORTANT: GitHub blocks self-approval** — all agents share the same credentials, so \`--approve\` and \`--request-changes\` will fail with "can't approve your own PR." Use \`--comment\` instead.\n\n` +
+      `Submit your review verdict using \`gh pr review\` with \`--comment\`:\n` +
+      `- Approve: \`gh pr review <number> --comment --body "VERDICT: APPROVE\\n\\n<your review details>" --repo ${org}/${repo}\`\n` +
+      `- Request changes: \`gh pr review <number> --comment --body "VERDICT: REQUEST_CHANGES\\n\\n<your review details>" --repo ${org}/${repo}\`\n` +
       `- Replace <number> with the PR number\n` +
       `- Always set --repo to \`${org}/${repo}\` to target the correct repository\n` +
-      `- Use --body to provide a review summary (supports Markdown)`;
+      `- **Your comment body MUST start with \`VERDICT: APPROVE\` or \`VERDICT: REQUEST_CHANGES\`** on its own line — the engine parses this to record your vote\n` +
+      `- Do NOT use \`--approve\` or \`--request-changes\` flags — they will fail`;
   }
   return `Use \`mcp__azure-ado__repo_update_pull_request_reviewers\`:\n- repositoryId: \`${repoId}\`\n- Set your reviewer vote on the PR (10=approve, 5=approve-with-suggestions, -10=reject)`;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.888",
+  "version": "0.1.890",
   "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/review.md

@@ -40,28 +40,22 @@ Use subagents only for genuinely parallel, independent tasks (e.g., reviewing un
    - Verdict: **APPROVE**
    - Note any minor non-blocking suggestions
 
-## Post Review — Two required actions, both mandatory
+## Post Review — Submit your verdict
 
-You MUST complete BOTH steps below. The review is NOT done until both are confirmed. A comment without a vote is an incomplete review.
+You MUST post a review comment with a clear verdict. The engine parses your verdict to update PR status — **a review without a verdict line is incomplete and will be retried.**
 
-### Step 1: Post a detailed review comment
-
-{{pr_comment_instructions}}
-- content: Your full review with verdict, findings, and sign-off
-- Sign: `Review by Minions ({{agent_name}} — {{agent_role}})`
-
-### Step 2: Submit a formal review vote — THIS IS REQUIRED
-
-**This is a separate action from Step 1.** Posting a comment does NOT submit a vote. You must explicitly run the vote command:
+### Post your review with verdict
 
 {{pr_vote_instructions}}
-- If your verdict is **APPROVE**: use `--approve`
-- If your verdict is **REQUEST_CHANGES**: use `--request-changes`
-- If you have minor non-blocking suggestions only: use `--approve` with a note
 
-**Do not stop after Step 1.** The task is incomplete until Step 2 is done.
+Your review body **MUST** start with one of these verdict lines (exactly as shown):
+- `VERDICT: APPROVE` — if the code is ready to merge
+- `VERDICT: REQUEST_CHANGES` — if there are issues that must be fixed
+
+Follow the verdict line with your detailed review findings, then sign off:
+- Sign: `Review by Minions ({{agent_name}} — {{agent_role}})`
 
-After running the vote command, confirm it succeeded (check the command output for errors). If it fails, retry once.
+After running the command, confirm it succeeded (check the command output for errors). If it fails, retry once.
 
 ## Handling Merge Conflicts
 If you encounter merge conflicts (e.g., the PR shows conflicts):
@@ -71,9 +65,7 @@ If you encounter merge conflicts (e.g., the PR shows conflicts):
 
 ## When to Stop
 
-Your task is complete only when BOTH of these are true:
-1. Review comment posted (Step 1)
-2. Formal vote submitted via `gh pr review --approve` or `--request-changes` (Step 2)
+Your task is complete when your review comment (with `VERDICT: APPROVE` or `VERDICT: REQUEST_CHANGES` on the first line) has been posted successfully.
 
-Do NOT stop after only posting a comment. Do NOT continue reading unrelated files after voting.
+Do NOT stop before posting the review. Do NOT continue reading unrelated files after posting.