@link-assistant/hive-mind 1.72.5 → 1.72.6

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @link-assistant/hive-mind
 
+## 1.72.6
+
+### Patch Changes
+
+- 57f15ec: Detect same-account human feedback in auto-restart comment monitoring only when the AI tool is idle, while still filtering hive-mind tool-generated comments by marker and tracked ID.
+
 ## 1.72.5
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.72.5",
+  "version": "1.72.6",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",

package/src/solve.auto-merge-helpers.lib.mjs

@@ -76,7 +76,7 @@ const formatRunLine = run => {
 // search scope for checkForExistingComment() stays in lock-step with the
 // markers actually embedded in tool-posted comments.
 const toolComments = await import('./tool-comments.lib.mjs');
-const { SESSION_ENDING_MARKERS } = toolComments;
+const { SESSION_ENDING_MARKERS, isToolGeneratedComment, isToolTrackedCommentId } = toolComments;
 
 /**
  * Issue #1323: Check if a comment with specific content already exists on the PR
@@ -168,14 +168,25 @@ export const checkForExistingComment = async (owner, repo, prNumber, commentSign
 
 /**
  * Check for new comments from non-bot users since last commit
+ *
+ * Same-account comments are only considered feedback when
+ * `trustAuthenticatedUserComments` is true. Keep the default false for callers
+ * that may run while an AI tool is still active: those tools can post through
+ * the authenticated GitHub account.
+ *
+ * @param {Function} commandRunner - Tagged-template command runner, injectable for tests
+ * @param {Object} options - Comment classification options
+ * @param {boolean} options.trustAuthenticatedUserComments - True only when the caller knows the AI tool is not running
  * @returns {Promise<{hasNewComments: boolean, comments: Array}>}
  */
-export const checkForNonBotComments = async (owner, repo, prNumber, issueNumber, lastCheckTime, verbose = false) => {
+export const checkForNonBotComments = async (owner, repo, prNumber, issueNumber, lastCheckTime, verbose = false, commandRunner = $, options = {}) => {
   try {
+    const { trustAuthenticatedUserComments = false } = options;
+
     // Get current GitHub user to identify which comments are from the bot/hive-mind
     let currentUser = null;
     try {
-      const userResult = await $`gh api user --jq .login`;
+      const userResult = await commandRunner`gh api user --jq .login`;
       if (userResult.code === 0) {
         currentUser = userResult.stdout.toString().trim();
       }
@@ -183,7 +194,12 @@ export const checkForNonBotComments = async (owner, repo, prNumber, issueNumber,
       // If we can't get the current user, continue without filtering
     }
 
-    // Common bot usernames and patterns to filter out
+    // Common bot usernames and patterns to filter out.
+    // Issue #1821: In same-account operation, humans and AI tools can both
+    // post through the authenticated account. The safe default treats that
+    // account as tool-owned; auto-restart-until-mergeable opts in to trusting
+    // same-account comments only while no AI tool execution is active, and
+    // still filters tool-generated comments by tracked IDs and marker strings.
     // Note: Patterns use word boundaries or end-of-string to avoid false positives
     // (e.g., "claudeuser" should NOT match as a bot)
     const botPatterns = [
@@ -201,21 +217,21 @@ export const checkForNonBotComments = async (owner, repo, prNumber, issueNumber,
 
     const isBot = login => {
       if (!login) return false;
-      // Check if it's the current user (the bot running hive-mind)
-      if (currentUser && login === currentUser) return true;
       // Check against known bot patterns
       return botPatterns.some(pattern => pattern.test(login));
     };
 
+    const isToolComment = comment => isToolTrackedCommentId(comment.id) || isToolGeneratedComment(comment.body);
+
     // Fetch PR conversation comments
-    const prCommentsResult = await $`gh api repos/${owner}/${repo}/issues/${prNumber}/comments --paginate`;
+    const prCommentsResult = await commandRunner`gh api repos/${owner}/${repo}/issues/${prNumber}/comments --paginate`;
     let prComments = [];
     if (prCommentsResult.code === 0 && prCommentsResult.stdout) {
       prComments = JSON.parse(prCommentsResult.stdout.toString() || '[]');
     }
 
     // Fetch PR review comments (inline code comments)
-    const prReviewCommentsResult = await $`gh api repos/${owner}/${repo}/pulls/${prNumber}/comments --paginate`;
+    const prReviewCommentsResult = await commandRunner`gh api repos/${owner}/${repo}/pulls/${prNumber}/comments --paginate`;
     let prReviewComments = [];
     if (prReviewCommentsResult.code === 0 && prReviewCommentsResult.stdout) {
       prReviewComments = JSON.parse(prReviewCommentsResult.stdout.toString() || '[]');
@@ -224,7 +240,7 @@ export const checkForNonBotComments = async (owner, repo, prNumber, issueNumber,
     // Fetch issue comments if we have an issue number
     let issueComments = [];
     if (issueNumber && issueNumber !== prNumber) {
-      const issueCommentsResult = await $`gh api repos/${owner}/${repo}/issues/${issueNumber}/comments --paginate`;
+      const issueCommentsResult = await commandRunner`gh api repos/${owner}/${repo}/issues/${issueNumber}/comments --paginate`;
       if (issueCommentsResult.code === 0 && issueCommentsResult.stdout) {
         issueComments = JSON.parse(issueCommentsResult.stdout.toString() || '[]');
       }
@@ -233,14 +249,28 @@ export const checkForNonBotComments = async (owner, repo, prNumber, issueNumber,
     // Combine all comments
     const allComments = [...prComments, ...prReviewComments, ...issueComments];
 
-    // Filter for new comments from non-bot users
+    // Filter for new comments from non-bot users. Automated hive-mind/tool
+    // comments are excluded by marker/ID, including comments posted by the
+    // authenticated user during the current or a previous process.
     const newNonBotComments = allComments.filter(comment => {
       const commentTime = new Date(comment.created_at);
       const isAfterLastCheck = commentTime > lastCheckTime;
-      const isFromNonBot = !isBot(comment.user?.login);
-
-      if (verbose && isAfterLastCheck && isFromNonBot) {
-        console.log(`[VERBOSE] New non-bot comment from ${comment.user?.login} at ${comment.created_at}`);
+      const login = comment.user?.login;
+      const isFromAuthenticatedUser = Boolean(currentUser && login === currentUser);
+      const isFromTool = isToolComment(comment);
+      const isFromAuthenticatedUserToolContext = isFromAuthenticatedUser && !trustAuthenticatedUserComments;
+      const isFromBot = isBot(login) || isFromAuthenticatedUserToolContext;
+      const isFromNonBot = !isFromBot && !isFromTool;
+
+      if (verbose && isAfterLastCheck && isFromTool) {
+        console.log(`[VERBOSE] Skipping tool-generated comment from ${login} at ${comment.created_at}`);
+      } else if (verbose && isAfterLastCheck && isFromAuthenticatedUserToolContext) {
+        console.log(`[VERBOSE] Skipping authenticated-user comment from ${login} at ${comment.created_at} because same-account feedback is not trusted in this context`);
+      } else if (verbose && isAfterLastCheck && isFromBot) {
+        console.log(`[VERBOSE] Skipping bot comment from ${login} at ${comment.created_at}`);
+      } else if (verbose && isAfterLastCheck && isFromNonBot) {
+        const sameAccountSuffix = currentUser && login === currentUser ? ' (authenticated user)' : '';
+        console.log(`[VERBOSE] New non-bot comment from ${login}${sameAccountSuffix} at ${comment.created_at}`);
       }
 
       return isAfterLastCheck && isFromNonBot;

package/src/solve.auto-merge.lib.mjs

@@ -206,8 +206,12 @@ export const watchUntilMergeable = async params => {
         // Keep the counter as-is (it reached the safety valve or wasn't needed).
       }
 
-      // Check for new comments from non-bot users
-      const { hasNewComments, comments } = await checkForNonBotComments(owner, repo, prNumber, issueNumber, lastCheckTime, argv.verbose);
+      // Check for new comments from non-bot users. At this point the AI tool
+      // is not executing, so same-account non-tool comments can be trusted as
+      // human feedback while known tool comments remain filtered by markers/IDs.
+      const { hasNewComments, comments } = await checkForNonBotComments(owner, repo, prNumber, issueNumber, lastCheckTime, argv.verbose, $, {
+        trustAuthenticatedUserComments: true,
+      });
 
       // Check for uncommitted changes using shared utility
       const hasUncommittedChanges = await checkForUncommittedChanges(tempDir, argv);