@yemi33/minions 0.1.1911 → 0.1.1912

package/engine/copilot-models.json

@@ -0,0 +1,5 @@
+{
+  "runtime": "copilot",
+  "models": null,
+  "cachedAt": "2026-05-13T19:11:26.190Z"
+}

package/engine/gh-comment.js

@@ -46,6 +46,12 @@ const REPO_SLUG_RE = /^[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/;
 const MINIONS_COMMENT_MARKER_RE =
   /^<!--\s*minions:agent=([^\s]+)\s+kind=([^\s]+)(?:\s+wi=([^\s]+))?\s*-->/m;
 
+// Sample marker constant for tests / fixtures that need a body with a
+// canonical-format marker but don't care about the specific agent / kind /
+// wi fields. Matches MINIONS_COMMENT_MARKER_RE. Production comments build
+// their marker via _buildMarker / buildMinionsCommentBody.
+const MINIONS_COMMENT_MARKER = '<!-- minions:agent=minions kind=marker -->';
+
 // Cheaper "is this body already marked?" check that matches only at position 0
 // (for idempotency in buildMinionsCommentBody). Kept separate from the
 // exported regex so the public regex can be used by downstream classifiers
@@ -231,6 +237,7 @@ module.exports = {
   // Builders / parsers (pure functions — usable from anywhere)
   buildMinionsCommentBody,
   parseMinionsMarker,
+  MINIONS_COMMENT_MARKER,
   MINIONS_COMMENT_MARKER_RE,
   // Validation regexes (exported for downstream consumers)
   AGENT_ID_RE,

package/engine/github.js

@@ -7,6 +7,7 @@
 const shared = require('./shared');
 const { exec, execAsync, getProjects, projectPrPath, projectWorkItemsPath, safeJson, safeJsonArr, safeWrite, mutateJsonFileLocked, MINIONS_DIR, getPrLinks, backfillPrPrdItems, log, ts, dateStamp, PR_STATUS, PR_POLLABLE_STATUSES, createThrottleTracker, getProjectOrg } = shared;
 const { getPrs } = require('./queries');
+const { MINIONS_COMMENT_MARKER_RE } = require('./gh-comment');
 const path = require('path');
 
 // Lazy require to avoid circular dependency — only needed for engine().handlePostMerge
@@ -85,131 +86,94 @@ function _isNonActionableComment(c, config = {}) {
   if (_isAgentComment(c)) return true;
   if (_isCiReportCommentBody(c?.body)) return true;
   if (_isPreviewStatusComment(c)) return true;
-  if (_isAgentPositiveSignalComment(c, config)) return true;
+  if (_isMinionsAuthoredComment(c)) return true;
   return false;
 }
 
-// P-a3f9b2c1 — Detect agent self-positive-signal comments (verification SUCCESS reports,
-// VERDICT:APPROVE recaps, noop:true confessions) posted via the shared `gh` PAT identity.
+// W-mp3bp0ha000997ab-b — Structural classifier for Minions-authored PR comments.
 //
-// Sibling to PR #2431's `_isAgentSelfReviewDeclinedComment` but keys off body-shape markers
-// + an opt-in shared-minions login allowlist (REST `/issues/:n/comments` doesn't expose
-// GraphQL's `viewerDidAuthor` flag, so we approximate via configured logins).
+// Replaces the body-shape classifier chain (PR #2431's _isAgentSelfReviewDeclinedComment,
+// PR #2442's _isAgentPositiveSignalComment + _hasAgentPositiveSignalBody) with a single
+// structural check: a Minions-authored comment carries `MINIONS_COMMENT_MARKER` (defined
+// in engine/gh-comment.js) on its own first line AND was authored by the viewer (the
+// shared PAT identity used by all minions agents).
 //
-// Configuration:
-//   engine.botCommentLogins: string[]  — primary opt-in list (e.g. ['yemi33'])
-//   engine.ignoredCommentAuthors: string[]  — fallback (back-compat with existing knob)
+// Both gates are required:
+//   - `viewerDidAuthor: true` prevents humans from spoofing the marker by quoting it.
+//   - `MINIONS_COMMENT_MARKER_RE` enforces "own first line" — quoted markers in the
+//     middle of a comment, or markers with trailing content on the same line, do NOT
+//     match. This is the structural complement to the viewer check.
 //
-// Reference: PR #2433 (3 consecutive noop fix-dispatches when verify agents posted
-// "Result: SUCCESS" comments via the shared yemi33 PAT identity).
-function _sharedMinionsLogins(config = {}) {
-  const primary = Array.isArray(config?.engine?.botCommentLogins) ? config.engine.botCommentLogins : [];
-  const fallback = Array.isArray(config?.engine?.ignoredCommentAuthors) ? config.engine.ignoredCommentAuthors : [];
-  return new Set([...primary, ...fallback].map(s => String(s || '').toLowerCase()).filter(Boolean));
+// Production note: the GitHub REST endpoints we poll (/issues/:n/comments and
+// /pulls/:n/comments) do NOT populate `viewerDidAuthor` — that field is GraphQL-
+// only. `pollPrHumanComments` therefore backfills it via `_backfillViewerDidAuthor`
+// using the viewer login resolved by `_resolveViewerLogin` (one `gh api user` call
+// per process). This keeps the classifier alive in production without forcing a
+// GraphQL migration on every fetch site.
+//
+// Sub-item -a populates the marker on every minions-posted comment via a helper.
+// Sub-item -c migrates existing engine call sites + playbook examples.
+function _isMinionsAuthoredComment(c) {
+  if (!c || c.viewerDidAuthor !== true) return false;
+  const body = c.body || '';
+  const m = MINIONS_COMMENT_MARKER_RE.exec(body);
+  if (!m) return false;
+  // Strict: marker must be on its OWN first line (no leading content,
+  // no trailing content on the same line). MINIONS_COMMENT_MARKER_RE uses
+  // /m so it would otherwise match the start of any line; we additionally
+  // require the match to be at index 0 AND to occupy the first line
+  // exactly (modulo surrounding whitespace).
+  if (m.index !== 0) return false;
+  const lineEnd = body.indexOf('\n');
+  const firstLine = lineEnd === -1 ? body : body.slice(0, lineEnd);
+  return firstLine.trim() === m[0].trim();
 }
 
-// Pure body-shape matcher for agent positive-signal markers in PR comments.
-// Triggers on:
-//   - "Verification SUCCESS" / "Verification SUCCEEDED" / "Verification ran" (verify-dispatch reports)
-//   - "Result: SUCCESS" (verify-dispatch report header per playbooks/verify.md)
-//   - "VERDICT: APPROVE" (review-loop positive verdict — defense-in-depth alongside _hasMinionsReviewVerdict)
-//   - `noop: true` / `"noop": true` (completion-report-style noop confession copied to comment)
-function _hasAgentPositiveSignalBody(body) {
-  const text = String(body || '');
-  if (!text) return false;
-  if (/(?:^|\n)\s*\*{0,2}VERDICT[:\s]+\*{0,2}APPROVE\b/i.test(text)) return true;
-  if (/"?\bnoop\b"?\s*:\s*true\b/i.test(text)) return true;
-  if (/\bVerification\s+(?:SUCCESS(?:FUL|FULLY)?|SUCCEEDED|ran)\b/i.test(text)) return true;
-  if (/(?:^|\n)\s*#{0,3}\s*Result\s*:\s*SUCCESS\b/i.test(text)) return true;
-  return false;
+// ─── Viewer Login Resolution ────────────────────────────────────────────────
+// `_isMinionsAuthoredComment` (above) gates on `c.viewerDidAuthor === true`.
+// That field is populated by GitHub's GraphQL API but NOT by the REST
+// `/issues/:n/comments` and `/pulls/:n/comments` endpoints we use in
+// `pollPrHumanComments` (REST returns `viewerDidAuthor: null`). To make the
+// classifier alive in production without changing every fetch site to
+// GraphQL, we backfill the field by comparing the comment author's login to
+// the viewer login resolved via `gh api user` once per process. The shared
+// PAT identity does not change during a process lifetime, so a simple
+// in-memory cache is sufficient.
+let _cachedViewerLogin = null;
+
+async function _resolveViewerLogin() {
+  if (_cachedViewerLogin) return _cachedViewerLogin;
+  try {
+    const result = await execAsync('gh api user', { timeout: 10000, encoding: 'utf-8', maxBuffer: GH_MAX_BUFFER });
+    const parsed = JSON.parse(String(result || ''));
+    const login = parsed?.login ? String(parsed.login).toLowerCase() : null;
+    if (login) _cachedViewerLogin = login;
+    return login;
+  } catch (e) {
+    log('warn', `GitHub viewer-login resolution failed: ${e?.message || e}`);
+    return null;
+  }
 }
 
-function _isAgentPositiveSignalComment(c, config = {}) {
-  if (!c) return false;
-  const sharedLogins = _sharedMinionsLogins(config);
-  if (sharedLogins.size === 0) return false;
-  const login = String(c?.user?.login || '').toLowerCase();
-  if (!login || !sharedLogins.has(login)) return false;
-  return _hasAgentPositiveSignalBody(c.body);
+// Test hook: lets tests prime or clear the cached viewer login without
+// shelling out. Pass `null` to force a re-resolve on the next call.
+function _setCachedViewerLogin(login) {
+  _cachedViewerLogin = login ? String(login).toLowerCase() : null;
 }
 
-// W-mp2h696g000a7bc0 — Detect agent self-review-declined no-op comments.
-//
-// Per the documented contract (memory `subject: self-review`, docs/completion-reports.md:83-105):
-// when an agent is dispatched to review a PR they implemented, they post a `gh pr comment`
-// (no `VERDICT:` line) explaining the recusal and complete with `noop:true, verdict:null,
-// needs_rerun:true`. Because `gh` authenticates as the shared PAT user (`yemi33`), the
-// classifier can't tell the noop comment from a real human comment by author alone.
-//
-// Detection requires a stronger signal than author identity. Returns true only when BOTH:
-//   1. Body has NO `VERDICT:` line (we never want to swallow a real verdict comment), AND
-//   2. EITHER the body contains the canonical "Self-review declined" phrase AND references
-//      a dispatch id matching `<agent>-<type>-<uid>` that resolves to a same-agent
-//      review/implement dispatch in the completed history,
-//      OR the most recent review dispatch on this PR was assigned to the same agent as the
-//      PR author and completed with the noop:true / verdict:null / needs_rerun:true contract.
-//
-// This is a narrow allowlist for the noop pattern — generic PAT-user comments still flow
-// through `_isNonActionableComment` and trigger `humanFeedback.pendingFix=true` as before.
-function _isAgentSelfReviewDeclinedComment(c, { pr, dispatch } = {}) {
-  if (!c || !pr) return false;
-  const body = String(c.body || '');
-  if (!body) return false;
-  if (_hasMinionsReviewVerdict(body)) return false;
-
-  const prAuthorAgent = String(pr.agent || '').toLowerCase();
-  if (!prAuthorAgent) return false;
-
-  const completed = (dispatch && Array.isArray(dispatch.completed)) ? dispatch.completed : [];
-  const isNoopContract = (sc) => {
-    if (!sc || typeof sc !== 'object') return false;
-    if (sc.noop !== true && sc.noop !== 'true') return false;
-    if (sc.verdict !== null && sc.verdict !== undefined && sc.verdict !== '') return false;
-    if (sc.needs_rerun !== true && sc.needsRerun !== true) return false;
-    return true;
-  };
-
-  // Signal A — explicit "Self-review declined" phrase + verifiable dispatch id pointing
-  // at a same-agent review/implement/fix dispatch in the completed history.
-  const phraseMatch = /self[\s\-_]+review\s+declined/i.test(body);
-  if (phraseMatch) {
-    const dispatchIdMatches = body.match(/\b[a-z][a-z0-9]*-[a-z][a-z0-9]*-[a-z0-9]{8,}\b/g) || [];
-    for (const id of dispatchIdMatches) {
-      const entry = completed.find(d => d && d.id === id);
-      if (!entry) continue;
-      const agent = String(entry.agent || '').toLowerCase();
-      const t = String(entry.type || '').toLowerCase();
-      if (agent !== prAuthorAgent) continue;
-      if (t === 'review' || t === 'implement' || t === 'implement-large' || t === 'fix') {
-        return true;
-      }
-    }
+// Backfill `c.viewerDidAuthor` for an array of REST-fetched comments using
+// the resolved viewer login. Only sets the field when REST returned
+// null/undefined — never overrides a value that GraphQL or the test fixture
+// already supplied. Mutates the comment objects in place.
+function _backfillViewerDidAuthor(comments, viewerLogin) {
+  if (!Array.isArray(comments) || !viewerLogin) return;
+  for (const c of comments) {
+    if (!c || typeof c !== 'object') continue;
+    if (c.viewerDidAuthor === true || c.viewerDidAuthor === false) continue;
+    const login = c.user?.login;
+    if (typeof login !== 'string' || !login) continue;
+    c.viewerDidAuthor = login.toLowerCase() === viewerLogin;
   }
-
-  // Signal B — most recent review dispatch on this PR was assigned to the PR author
-  // and completed with the documented noop contract. Catches the case where the agent
-  // forgot the canonical phrase but the completion-report contract still flags a noop.
-  const prId = String(pr.id || '');
-  const prNumberRaw = pr.prNumber;
-  const prNumber = prNumberRaw == null ? null : Number(prNumberRaw);
-  const reviewDispatches = completed.filter(d => {
-    if (!d || String(d.type || '').toLowerCase() !== 'review') return false;
-    const dpr = d.meta && d.meta.pr;
-    if (!dpr) return false;
-    if (prId && String(dpr.id || '') === prId) return true;
-    if (prNumber != null && Number(dpr.prNumber) === prNumber) return true;
-    return false;
-  });
-  if (reviewDispatches.length === 0) return false;
-  reviewDispatches.sort((a, b) => {
-    const ta = String(a.completed_at || a.created_at || '');
-    const tb = String(b.completed_at || b.created_at || '');
-    return tb.localeCompare(ta);
-  });
-  const latest = reviewDispatches[0];
-  if (!latest) return false;
-  if (String(latest.agent || '').toLowerCase() !== prAuthorAgent) return false;
-  return isNoopContract(latest.structuredCompletion);
 }
 
 // ─── Per-Repo Poll Backoff ──────────────────────────────────────────────────
@@ -821,13 +785,18 @@ async function pollPrStatus(config) {
 
 async function pollPrHumanComments(config) {
   // Load dispatch state once per poll cycle (cached for ~2s by queries.getDispatch).
-  // Used by `_isAgentSelfReviewDeclinedComment` to verify dispatch ids referenced in
-  // candidate noop comments belong to the PR author.
+  // (Previously used by `_isAgentSelfReviewDeclinedComment` to verify dispatch ids;
+  // kept loaded in case downstream phases need dispatch context — cheap on cache hit.)
   const queries = require('./queries');
   const dispatch = (() => {
     try { return queries.getDispatch(); }
     catch { return { pending: [], active: [], completed: [] }; }
   })();
+  // Resolve viewer login once per poll cycle so we can backfill
+  // `viewerDidAuthor` on REST comments — the field GraphQL would have
+  // populated. `_resolveViewerLogin` caches process-wide, so repeated calls
+  // across PRs are free.
+  const viewerLogin = await _resolveViewerLogin();
   const totalUpdated = await forEachActiveGhPr(config, async (project, pr, prNum, slug) => {
     // Get issue comments (general PR comments)
     const comments = await ghApi(`/issues/${prNum}/comments`, slug);
@@ -840,6 +809,11 @@ async function pollPrHumanComments(config) {
       ...(Array.isArray(reviewComments) ? reviewComments : []).map(c => ({ ...c, _type: 'review' }))
     ];
 
+    // Backfill viewerDidAuthor on each comment so _isMinionsAuthoredComment
+    // can actually fire on production traffic. No-op when GraphQL or a test
+    // fixture already populated the field.
+    _backfillViewerDidAuthor(allComments, viewerLogin);
+
     const cutoffStr = pr.humanFeedback?.lastProcessedCommentDate || pr.created || '1970-01-01';
     const cutoffMs = new Date(cutoffStr).getTime() || 0;
 
@@ -853,12 +827,12 @@ async function pollPrHumanComments(config) {
     for (const c of allComments) {
       const date = c.created_at || c.updated_at || '';
       const dateMs = date ? new Date(date).getTime() : 0;
-      // W-mp2h696g000a7bc0 — agent self-review-declined no-op comments are posted via
-      // `gh pr comment` and authenticate as the shared PAT user, so author identity alone
-      // can't distinguish them from real human feedback. The narrow allowlist check uses
-      // the comment body + dispatch history to identify the documented noop pattern.
-      const isNonActionable = _isNonActionableComment(c, config)
-        || _isAgentSelfReviewDeclinedComment(c, { pr, dispatch });
+      // W-mp3bp0ha000997ab-b — All non-actionable filtering routes through
+      // _isNonActionableComment, which now composes _isMinionsAuthoredComment
+      // (structural marker check). The previous OR chain that appended
+      // _isAgentSelfReviewDeclinedComment is gone — that helper was deleted
+      // with this PR.
+      const isNonActionable = _isNonActionableComment(c, config);
       if (dateMs) allCommentDates.push(date);
       if (isNonActionable) continue;
       const entry = {
@@ -883,26 +857,6 @@ async function pollPrHumanComments(config) {
     }
     if (newComments.length === 0) return false;
 
-    // P-a3f9b2c1 — Defense-in-depth: when the PR is already approved AND every new comment
-    // is from a configured shared-minions PAT identity AND every new comment matches the
-    // positive-signal body shape, suppress pendingFix and advance cutoff. Belt-and-suspenders
-    // against future regressions in `_isAgentPositiveSignalComment`. This is intentionally
-    // narrow — a single human-shaped comment in newComments (e.g. "rename _foo to bar") will
-    // disqualify the entire batch and let the normal human-feedback flow run.
-    if (String(pr.reviewStatus || '').toLowerCase() === 'approved') {
-      const sharedLogins = _sharedMinionsLogins(config);
-      if (sharedLogins.size > 0) {
-        const allFromSharedPat = newComments.every(nc => sharedLogins.has(String(nc.author || '').toLowerCase()));
-        const allPositiveShape = newComments.every(nc => _hasAgentPositiveSignalBody(nc.content));
-        if (allFromSharedPat && allPositiveShape) {
-          const cutoff = allNewDates.sort().pop() || newComments[newComments.length - 1].date;
-          pr.humanFeedback = { ...(pr.humanFeedback || {}), lastProcessedCommentDate: cutoff };
-          log('info', `PR ${pr.id}: ${newComments.length} new shared-PAT positive-signal comment(s) on approved PR — defense-in-depth suppression`);
-          return true;
-        }
-      }
-    }
-
     // Sort all comments chronologically and build full context for the fix agent
     allCommentEntries.sort((a, b) => a.date.localeCompare(b.date));
     newComments.sort((a, b) => a.date.localeCompare(b.date));
@@ -1200,9 +1154,9 @@ module.exports = {
   _hasMinionsReviewVerdict, // exported for testing
   _isAgentComment, // exported for testing
   _isNonActionableComment, // exported for testing
-  _isAgentSelfReviewDeclinedComment, // exported for testing
-  _isAgentPositiveSignalComment, // exported for testing (P-a3f9b2c1)
-  _hasAgentPositiveSignalBody, // exported for testing (P-a3f9b2c1)
-  _sharedMinionsLogins, // exported for testing (P-a3f9b2c1)
+  _isMinionsAuthoredComment, // exported for testing (W-mp3bp0ha000997ab-b)
   _isPreviewStatusComment, // exported for testing
+  _resolveViewerLogin, // exported for testing (W-mp3bp0ha000997ab-b backfill)
+  _setCachedViewerLogin, // exported for testing (W-mp3bp0ha000997ab-b backfill)
+  _backfillViewerDidAuthor, // exported for testing (W-mp3bp0ha000997ab-b backfill)
 };

package/package.json

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