@yemi33/minions 0.1.2424 → 0.1.2426

package/engine/ado.js

@@ -10,8 +10,13 @@ const { exec, execAsync, getAdoOrgBase, log, ts, dateStamp, PR_STATUS, BUILD_STA
 const { getPrs } = require('./queries');
 const { mutateJsonFileLocked } = shared;
 const { acquireAdoToken } = require('./ado-token');
-const { isPreviewStatusBody, hasMinionsMarker, hasVerdictPrefix } = require('./comment-classifier');
+const {
+  hasMinionsMarker,
+  hasVerdictPrefix,
+  classifyNonActionableAutomationComment,
+} = require('./comment-classifier');
 const { wrapUntrusted, buildSource } = require('./untrusted-fence');
+const reviewLearning = require('./review-learning');
 
 // Lazy require to avoid circular dependency — only needed for engine().handlePostMerge
 let _engine = null;
@@ -2015,26 +2020,35 @@ async function pollPrHumanComments(config) {
         // Track date for cutoff BEFORE author/body filters so bot/CI/ignored
         // comments still advance the cutoff.
         if (comment.publishedDate) allCommentDates.push(comment.publishedDate);
-        if (comment.id != null) {
-          threadIdByComment.set(String(comment.id), thread.id);
-          editsInput.push({
-            id: comment.id,
-            createdRaw: comment.publishedDate,
-            updatedRaw: comment.lastUpdatedDate,
-          });
-        }
+        if (comment.id == null) continue;
+        threadIdByComment.set(String(comment.id), thread.id);
+        const commentSource = reviewLearning.buildReviewCommentSource({
+          host: 'ado',
+          threadId: thread.id,
+          commentType: comment.commentType || 'text',
+          commentId: comment.id,
+          author: comment.author?.displayName || 'Human',
+          createdAt: comment.publishedDate,
+          updatedAt: comment.lastUpdatedDate || comment.publishedDate,
+          content,
+        });
+        editsInput.push({
+          id: commentSource.key,
+          createdRaw: comment.publishedDate,
+          updatedRaw: comment.lastUpdatedDate,
+        });
         // Skip explicitly ignored authors.
         const authorName = (comment.author?.displayName || '').toLowerCase();
         if (ignoredAuthors.some(a => authorName.includes(a))) continue;
-        // P-f23classifier (F2): filter preview-status / CI-report bot bodies
-        // (Firebase / Appetize / Deploy / Preview / Coverage-Build-Test
-        // headings / shields.io badges) for parity with engine/github.js
-        // _isPreviewStatusComment. ADO has no `user.type === 'bot'` flag,
-        // so the filter is body-only — same behavior the inline ADO CI
-        // filter had before extraction, now broadened to include the GH
-        // preview signatures so a Firebase/Appetize bot comment on an ADO
-        // PR no longer advances pendingFix.
-        if (isPreviewStatusBody(content)) continue;
+        // Filter known automation noise by shared content/identity envelopes.
+        // This retains body-only preview/status matching while allowing
+        // actionable findings from the same PR Assistant/GitOps author.
+        const automationReason = classifyNonActionableAutomationComment({
+          host: 'ado',
+          body: content,
+          author: comment.author,
+        });
+        if (automationReason) continue;
         // P-f23classifier (F3): detect agent comments (included in context
         // but don't trigger fix). Structurally symmetric to
         // engine/github.js _isAgentComment + _isMinionsAuthoredComment:
@@ -2055,7 +2069,10 @@ async function pollPrHumanComments(config) {
           author: comment.author?.displayName || 'Human',
           content: comment.content,
           date: comment.publishedDate,
-          _isAgent: isAgent
+          createdAt: comment.publishedDate,
+          updatedAt: comment.lastUpdatedDate || comment.publishedDate,
+          _isAgent: isAgent,
+          commentSource,
         };
         allHumanComments.push(entry);
 
@@ -2072,35 +2089,61 @@ async function pollPrHumanComments(config) {
     // edit timestamp differs from what we already saw queue as new feedback
     // (re-dispatch). First-seen comments and re-polls of already-seen edits
     // do NOT route through this path.
-    const prevEditsSeen = (pr.humanFeedback && pr.humanFeedback.editsSeen) || {};
+    const persistedEditsSeen = pr.humanFeedback?.editsSeen || {};
+    const prevEditsSeen = reviewLearning.migrateLegacyReviewCommentEdits(
+      persistedEditsSeen,
+      editsInput.map(entry => entry.id),
+    );
+    const editsMigrationChanged = JSON.stringify(prevEditsSeen) !== JSON.stringify(persistedEditsSeen);
     editsInput.sort((a, b) => String(a.updatedRaw || '').localeCompare(String(b.updatedRaw || '')));
-    const { editsSeen, newlyEditedIds, changed: editsSeenChanged } =
+    const { editsSeen, newlyEditedIds, changed } =
       shared.buildEditsSeen(editsInput, prevEditsSeen);
+    const editsSeenChanged = changed || editsMigrationChanged;
 
     // F6: promote pre-cutoff comments that were newly edited into newHumanComments
     // (agent-authored edits do NOT re-dispatch — vote path handles agent reviews).
-    const seenNewCommentIds = new Set(newHumanComments.map(c => String(c.commentId)));
+    const seenNewCommentKeys = new Set(newHumanComments.map(c => c.commentSource.key));
     for (const entry of allHumanComments) {
       if (entry._isAgent) continue;
-      const id = String(entry.commentId);
-      if (seenNewCommentIds.has(id)) continue;
-      if (!newlyEditedIds.has(id)) continue;
-      newHumanComments.push({ ...entry, date: editsSeen[id] || entry.date, _isEditedRedispatch: true });
-      seenNewCommentIds.add(id);
+      const key = entry.commentSource.key;
+      if (seenNewCommentKeys.has(key)) continue;
+      if (!newlyEditedIds.has(key)) continue;
+      entry._isEditedRedispatch = true;
+      newHumanComments.push({
+        ...entry,
+        date: editsSeen[key] || entry.commentSource.updatedAt || entry.date,
+      });
+      seenNewCommentKeys.add(key);
     }
 
+    allHumanComments.sort((a, b) => a.date.localeCompare(b.date));
+    const currentFeedback = pr.humanFeedback || {};
+    const observedCommentSources = reviewLearning.normalizeReviewCommentSources(
+      allHumanComments.map(entry => entry.commentSource),
+    );
+    const commentSources = reviewLearning.selectReviewCommentSourceSnapshot(
+      currentFeedback,
+      observedCommentSources,
+    );
+    const commentSourcesChanged = JSON.stringify(commentSources)
+      !== JSON.stringify(reviewLearning.normalizeReviewCommentSources(currentFeedback.commentSources));
+
     // Persist cutoff unconditionally for any new comment we observed — even
     // if every new comment was bot/CI/ignored/agent. Mirrors GitHub poller.
     const allNewDates = allCommentDates.filter(d => (new Date(d).getTime() || 0) > cutoffMs);
     if (allNewDates.length > 0 && newHumanComments.length === 0) {
-      pr.humanFeedback = { ...(pr.humanFeedback || {}), lastProcessedCommentDate: allNewDates.sort().pop() };
+      pr.humanFeedback = { ...currentFeedback, lastProcessedCommentDate: allNewDates.sort().pop() };
+      if (commentSources.length > 0) pr.humanFeedback.commentSources = commentSources;
       if (editsSeenChanged) pr.humanFeedback.editsSeen = editsSeen;
       return true;
     }
     if (newHumanComments.length === 0) {
       // F6: persist pruned/updated editsSeen map even when no dispatch is queued.
-      if (editsSeenChanged) {
-        pr.humanFeedback = { ...(pr.humanFeedback || {}), editsSeen };
+      if (editsSeenChanged || commentSourcesChanged) {
+        pr.humanFeedback = { ...currentFeedback };
+        if (commentSources.length > 0) pr.humanFeedback.commentSources = commentSources;
+        else delete pr.humanFeedback.commentSources;
+        if (editsSeenChanged) pr.humanFeedback.editsSeen = editsSeen;
         return true;
       }
       return false;
@@ -2109,7 +2152,6 @@ async function pollPrHumanComments(config) {
     // Sort all comments chronologically and build full context for the fix agent.
     // Cutoff advances to the latest of ALL new comment dates (so newer agent/CI
     // comments interleaved with the human feedback don't re-scan next tick).
-    allHumanComments.sort((a, b) => a.date.localeCompare(b.date));
     newHumanComments.sort((a, b) => a.date.localeCompare(b.date));
     const latestDate = allNewDates.sort().pop() || newHumanComments[newHumanComments.length - 1].date;
 
@@ -2120,7 +2162,10 @@ async function pollPrHumanComments(config) {
     const adoRepo = project?.repoName || project?.repositoryId || '';
     const feedbackContent = allHumanComments
       .map(c => {
-        const isNew = (new Date(c.date).getTime() || 0) > cutoffMs;
+        const isNew = c._isEditedRedispatch || (new Date(c.date).getTime() || 0) > cutoffMs;
+        const displayDate = c._isEditedRedispatch
+          ? (c.commentSource.updatedAt || c.updatedAt || c.date)
+          : c.date;
         const cleanedBody = String(c.content || '').replace(/@minions\s*/gi, '').trim();
         const source = buildSource('pr-comment', {
           host: 'ado',
@@ -2129,10 +2174,11 @@ async function pollPrHumanComments(config) {
           repo: adoRepo,
           number: prNum,
           author: c.author || 'unknown',
+          key: c.commentSource.key,
         });
         const fenced = wrapUntrusted(cleanedBody, source);
         const bodyForPrompt = fenced || cleanedBody;
-        return `${isNew ? '**[NEW]** ' : ''}**${c.author}** (${c.date}):\n${bodyForPrompt}`;
+        return `${isNew ? '**[NEW]** ' : ''}**${c.author}** (${displayDate}):\n${bodyForPrompt}`;
       })
       .join('\n\n---\n\n');
 
@@ -2143,6 +2189,7 @@ async function pollPrHumanComments(config) {
       lastProcessedCommentKey: `${latestNewHuman.threadId || threadIdByComment.get(String(latestNewHuman.commentId)) || ''}:${latestNewHuman.commentId}`,
       pendingFix: true,
       feedbackContent,
+      commentSources: observedCommentSources,
       editsSeen,
     };