@link-assistant/hive-mind 1.73.0 → 1.73.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @link-assistant/hive-mind
 
+## 1.73.1
+
+### Patch Changes
+
+- df8b776: Stop the auto-restart-until-mergeable and watch loops from treating the AI agent's own session comments (e.g. free-form "CI now green" status updates posted through the authenticated account) as new human feedback, which caused an endless restart loop until the iteration limit (issue #1827). The check window is now advanced monotonically, every comment the authenticated account posts during a session is tracked by ID, and watch-mode feedback counting excludes tool-generated comments by marker and tracked ID.
+
 ## 1.73.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.73.0",
+  "version": "1.73.1",
   "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, isToolGeneratedComment, isToolTrackedCommentId } = toolComments;
+const { SESSION_ENDING_MARKERS, isToolGeneratedComment, isToolTrackedCommentId, trackToolCommentId } = toolComments;
 
 /**
  * Issue #1323: Check if a comment with specific content already exists on the PR
@@ -292,6 +292,121 @@ export const checkForNonBotComments = async (owner, repo, prNumber, issueNumber,
   }
 };
 
+/**
+ * Issue #1827: Compute the next monotonic check-window cutoff for the
+ * auto-restart-until-mergeable loop. The cutoff must never move backwards:
+ * after an AI session, lastCheckTime is set to a moment *after* the agent's own
+ * comments, so rewinding it to the iteration's start time (captured before the
+ * AI ran) would re-detect those comments as new feedback — the root cause of
+ * the restart loop in #1827. Returns whichever timestamp is later.
+ *
+ * @param {Date} lastCheckTime - current cutoff
+ * @param {Date} candidate - proposed new cutoff (usually the iteration start time)
+ * @returns {Date} the later of the two timestamps
+ */
+export const nextMonotonicCheckTime = (lastCheckTime, candidate) => {
+  if (!(lastCheckTime instanceof Date)) return candidate;
+  if (!(candidate instanceof Date)) return lastCheckTime;
+  return candidate.getTime() > lastCheckTime.getTime() ? candidate : lastCheckTime;
+};
+
+/**
+ * Issue #1827: Register every comment authored by the authenticated GitHub
+ * account during an AI working session as a tool-generated comment.
+ *
+ * During a session, the AI agent can post free-form status comments through the
+ * authenticated account (e.g. "✅ CI now green", "✅ Verification pass"). These
+ * are NOT routed through postTrackedComment(), so their IDs were never captured,
+ * and they match none of the tool markers. Once issue #1821 made the watch loop
+ * trust same-account comments as human feedback, the very next iteration
+ * re-detected these comments as fresh feedback and triggered an endless
+ * auto-restart loop until the limit was hit.
+ *
+ * Because the authenticated account is busy running the AI for the whole
+ * session window, any comment it authored within that window is the tool's own,
+ * not human feedback. Tracking those IDs makes checkForNonBotComments filter
+ * them by ID regardless of timestamps — a defense that also survives clock skew
+ * between the local clock and GitHub's `created_at` (which a purely
+ * time-based cutoff cannot).
+ *
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @param {number} prNumber - Pull request number
+ * @param {number} issueNumber - Issue number (may equal prNumber)
+ * @param {Date|string|number} sinceTime - Start of the session window
+ * @param {Function} commandRunner - Tagged-template command runner, injectable for tests
+ * @param {Object} options
+ * @param {boolean} [options.verbose=false]
+ * @param {string} [options.currentUser] - Pre-resolved authenticated login (skips the `gh api user` call)
+ * @returns {Promise<string[]>} Newly tracked comment IDs (as strings)
+ */
+export const trackAuthenticatedUserCommentsSince = async (owner, repo, prNumber, issueNumber, sinceTime, commandRunner = $, options = {}) => {
+  const { verbose = false, currentUser: providedUser } = options;
+  const trackedIds = [];
+
+  try {
+    let currentUser = providedUser || null;
+    if (!currentUser) {
+      try {
+        const userResult = await commandRunner`gh api user --jq .login`;
+        if (userResult.code === 0) {
+          currentUser = userResult.stdout.toString().trim();
+        }
+      } catch {
+        // Without the authenticated login we cannot attribute comments; bail out.
+      }
+    }
+    if (!currentUser) return trackedIds;
+
+    const since = sinceTime instanceof Date ? sinceTime : new Date(sinceTime);
+
+    const fetchComments = async path => {
+      try {
+        const result = await commandRunner`gh api ${path} --paginate`;
+        if (result.code === 0 && result.stdout) {
+          return JSON.parse(result.stdout.toString() || '[]');
+        }
+      } catch {
+        // Ignore fetch/parse failures for an individual endpoint.
+      }
+      return [];
+    };
+
+    const prComments = await fetchComments(`repos/${owner}/${repo}/issues/${prNumber}/comments`);
+    const prReviewComments = await fetchComments(`repos/${owner}/${repo}/pulls/${prNumber}/comments`);
+    let issueComments = [];
+    if (issueNumber && issueNumber !== prNumber) {
+      issueComments = await fetchComments(`repos/${owner}/${repo}/issues/${issueNumber}/comments`);
+    }
+
+    const allComments = [...prComments, ...prReviewComments, ...issueComments];
+    for (const comment of allComments) {
+      const login = comment.user?.login;
+      if (!login || login !== currentUser) continue;
+      // Inclusive lower bound: a comment posted at the exact session start is
+      // still the tool's own. created_at uses GitHub's clock, so allow equality.
+      const createdAt = new Date(comment.created_at);
+      if (createdAt < since) continue;
+      if (isToolTrackedCommentId(comment.id)) continue;
+      trackToolCommentId(comment.id);
+      trackedIds.push(String(comment.id));
+      if (verbose) {
+        console.log(`[VERBOSE] Tracking authenticated-user session comment ${comment.id} from ${login} at ${comment.created_at}`);
+      }
+    }
+  } catch (error) {
+    reportError(error, {
+      context: 'track_authenticated_user_comments',
+      owner,
+      repo,
+      prNumber,
+      operation: 'track_session_comments',
+    });
+  }
+
+  return trackedIds;
+};
+
 /**
  * Get the reasons why PR is not mergeable
  * Issue #1314: Comprehensive CI/CD status handling covering all possible states:

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

@@ -53,7 +53,7 @@ import { limitReset } from './config.lib.mjs';
 
 // Import helper functions extracted for file size management (Issue #1593)
 const autoMergeHelpers = await import('./solve.auto-merge-helpers.lib.mjs');
-const { checkForExistingComment, checkForNonBotComments, getMergeBlockers } = autoMergeHelpers;
+const { checkForExistingComment, checkForNonBotComments, getMergeBlockers, trackAuthenticatedUserCommentsSince, nextMonotonicCheckTime } = autoMergeHelpers;
 
 // Issue #1769: cancelled/stale CI re-run failures need a human action stop, not polling forever.
 const cancelledCiRerunLib = await import('./cancelled-ci-rerun.lib.mjs');
@@ -1031,6 +1031,26 @@ No further AI sessions will be started automatically for this run. Please review
           await log(formatAligned('✅', `${argv.tool.toUpperCase()} execution completed:`, 'Checking if PR is now mergeable...'));
         }
 
+        // Issue #1827: Register every comment the authenticated account posted
+        // during this AI session (free-form status comments like "✅ CI now
+        // green" the agent writes itself, which bypass postTrackedComment and
+        // match no tool marker). Tracking their IDs stops the next iteration's
+        // checkForNonBotComments from mistaking them for fresh human feedback.
+        try {
+          const tracked = await trackAuthenticatedUserCommentsSince(owner, repo, prNumber, issueNumber, iterationStartTime, $, { verbose: argv.verbose });
+          if (argv.verbose && tracked.length > 0) {
+            await log(formatAligned('🧷', 'Tracked own session comments:', `${tracked.length} (won't count as new feedback)`, 2));
+          }
+        } catch (trackError) {
+          reportError(trackError, {
+            context: 'track_authenticated_user_session_comments',
+            prNumber,
+            owner,
+            repo,
+            operation: 'track_session_comments',
+          });
+        }
+
         // Update last check time after restart
         lastCheckTime = new Date();
       } else if (blockers.length > 0) {
@@ -1071,8 +1091,16 @@ No further AI sessions will be started automatically for this run. Please review
         await log(formatAligned('', 'No action needed', 'Continuing to monitor...', 2));
       }
 
-      // Update last check time
-      lastCheckTime = currentTime;
+      // Issue #1827: Advance the check window monotonically — never move it
+      // backwards. In the restart branch above, lastCheckTime was already set
+      // to a moment *after* the AI session (and after any comments the agent
+      // posted). currentTime was captured at the *start* of this iteration,
+      // before the AI ran, so assigning it unconditionally here would rewind
+      // the window and re-detect the agent's own comments as new feedback
+      // (the root cause of the auto-restart loop in #1827). In the non-restart
+      // branches lastCheckTime is still the previous iteration's value, which
+      // is < currentTime, so this correctly advances it.
+      lastCheckTime = nextMonotonicCheckTime(lastCheckTime, currentTime);
     } catch (error) {
       reportError(error, {
         context: 'watch_until_mergeable',

package/src/solve.feedback.lib.mjs

@@ -7,6 +7,9 @@
 import { reportError } from './sentry.lib.mjs';
 
 import { wrapDollarWithGhRetry as _wrapDollarWithGhRetry } from './github-rate-limit.lib.mjs'; // rate-limit marker (#1726): gh API calls flow through $ wrapped by caller
+// Issue #1827: tool-generated comments (markers + in-memory tracked IDs) must
+// not count as feedback in watch/continue mode, mirroring checkForNonBotComments.
+import { isToolGeneratedComment, isToolTrackedCommentId } from './tool-comments.lib.mjs';
 export const detectAndCountFeedback = async params => {
   const { prNumber, branchName, owner, repo, issueNumber, isContinueMode, argv, mergeStateStatus, prState, workStartTime, log, formatAligned, cleanErrorMessage, $, repositoryPath = null } = params;
 
@@ -93,6 +96,14 @@ export const detectAndCountFeedback = async params => {
         // Define log patterns to filter out comments containing logs from solve.mjs
         const logPatterns = [/📊.*Log file|solution\s+draft.*log/i, /🔗.*Link:|💻.*Session:/i, /Generated with.*solve\.mjs/i, /Session ID:|Log file available:/i];
 
+        // Issue #1827: A comment is tool-generated if its ID was tracked in
+        // memory during this run (system status comments AND the agent's own
+        // session comments) or if its body carries a known tool marker (catches
+        // comments from previous runs whose IDs are gone). These must never
+        // count as feedback — otherwise the agent's own "CI now green" / status
+        // comments trigger an endless restart loop (see PR link-foundation/rust-web-box#34).
+        const isToolComment = comment => isToolTrackedCommentId(comment.id) || isToolGeneratedComment(comment.body);
+
         // Count new PR comments after last commit (both code review comments and conversation comments)
         let prReviewComments = [];
         let prConversationComments = [];
@@ -112,6 +123,10 @@ export const detectAndCountFeedback = async params => {
 
         // Helper function to filter comments based on time and log patterns
         const filterComment = comment => {
+          // Issue #1827: never count tool-generated comments as feedback.
+          if (isToolComment(comment)) {
+            return false;
+          }
           const commentTime = new Date(comment.created_at);
           const isAfterCommit = commentTime > lastCommitTime;
           const isNotLogPattern = !logPatterns.some(pattern => pattern.test(comment.body || ''));
@@ -145,6 +160,10 @@ export const detectAndCountFeedback = async params => {
         if (issueCommentsResult.code === 0) {
           const issueComments = JSON.parse(issueCommentsResult.stdout.toString());
           const filteredIssueComments = issueComments.filter(comment => {
+            // Issue #1827: never count tool-generated comments as feedback.
+            if (isToolComment(comment)) {
+              return false;
+            }
             const commentTime = new Date(comment.created_at);
             const isAfterCommit = commentTime > lastCommitTime;
             const isNotLogPattern = !logPatterns.some(pattern => pattern.test(comment.body || ''));

package/src/solve.watch.lib.mjs

@@ -46,6 +46,12 @@ const { formatAutoIterationLimit, hasReachedAutoIterationLimit, normalizeAutoIte
 const toolComments = await import('./tool-comments.lib.mjs');
 const { AUTO_RESTART_MARKER, postTrackedComment } = toolComments;
 
+// Issue #1827: After each AI session, register the authenticated account's own
+// comments (free-form status updates the agent posts itself) so the next
+// detectAndCountFeedback() call doesn't mistake them for new human feedback.
+const autoMergeHelpers = await import('./solve.auto-merge-helpers.lib.mjs');
+const { trackAuthenticatedUserCommentsSince } = autoMergeHelpers;
+
 // Issue #1728: Per-iteration working session summary attachment helper
 // Issue #1763: Per-iteration PR ↔ issue link verification (in case the AI
 // agent overwrites the PR body without a closing keyword and the iteration
@@ -340,6 +346,24 @@ export const watchForFeedback = async params => {
           global.previousSessionId = toolResult.sessionId;
         }
 
+        // Issue #1827: Track the authenticated account's own comments posted
+        // during this session window so they are filtered (by ID) on the next
+        // feedback check instead of re-triggering a restart.
+        try {
+          const tracked = await trackAuthenticatedUserCommentsSince(owner, repo, prNumber, issueNumber, iterationStartTime, $, { verbose: argv.verbose });
+          if (argv.verbose && tracked.length > 0) {
+            await log(formatAligned('🧷', 'Tracked own session comments:', `${tracked.length} (won't count as feedback)`, 2));
+          }
+        } catch (trackError) {
+          reportError(trackError, {
+            context: 'track_authenticated_user_session_comments',
+            prNumber,
+            owner,
+            repo,
+            operation: 'track_session_comments',
+          });
+        }
+
         if (!toolResult.success) {
           // Check if this is an API error using shared utility
           if (isApiError(toolResult)) {