@link-assistant/hive-mind 1.30.5 → 1.31.1

package/CHANGELOG.md

@@ -1,5 +1,78 @@
 # @link-assistant/hive-mind
 
+## 1.31.1
+
+### Patch Changes
+
+- 5108367: fix: fix root causes of 20-32h process hang after session ends (Issue #1335)
+
+  Two separate bugs caused `solve` processes to run for 20–32 hours after work was complete:
+
+  **Bug A — Infinite loop for repos without CI:** When `--auto-restart-until-mergeable` is used
+  on a repository with no CI/CD workflows, the `watchUntilMergeable` loop was permanently stuck
+  on "CI/CD checks have not started yet" with no exit condition. The root cause was that the code
+  treated `no_checks` identically for both transient race conditions (CI hasn't started yet after
+  a push) and permanent states (repo has no CI at all). Fixed by checking whether the repository
+  actually has GitHub Actions workflows configured (`hasRepoWorkflows()`). If none exist, the
+  `no_checks` state is permanent and the monitor exits immediately, treating the PR as CI-passing.
+  If workflows exist, the state is a transient race condition and the loop keeps waiting.
+
+  **Bug B — No process exit after session ends:** After a successful run (PR became mergeable,
+  work session ended), `solve.mjs` never called `process.exit()`. Sentry's profiling integration
+  (`@sentry/profiling-node`) kept the Node.js event loop alive indefinitely. Fixed by calling
+  `safeExit(0)` at the end of the `finally` block in `solve.mjs`, which flushes Sentry events
+  (up to 2 seconds) and then calls `process.exit(0)`.
+
+  Also adds `--verbose` debug logging of active Node.js handles at exit to aid diagnosis of
+  future occurrences.
+
+## 1.31.0
+
+### Minor Changes
+
+- feat: add --finalize option (Issue #1383)
+
+  Adds new experimental CLI options to the `solve` command:
+  - `--finalize [N]`: After the main solve completes, automatically restarts the AI tool N times (default: 1 when used as a flag) with a requirements-check prompt to verify all requirements are met. Uses the same model as `--model` by default.
+  - `--finalize-model`: Override the model used during `--finalize` iterations (defaults to `--model`).
+  - `--prompt-ensure-all-requirements-are-met`: Adds a system prompt hint in the "Self review" section instructing the AI to ensure all changes are correct, consistent, validated, tested, logged and fully meet all discussed requirements. Enabled automatically during `--finalize` iterations only (not the first regular run).
+
+  This forces the AI tool to double-check itself after the main solve, verifying changes meet all requirements from the issue description and PR comments, and that CI/CD checks pass.
+
+  feat: auto-commit uncommitted changes and upload log on CTRL+C interrupt (Issue #1351)
+
+  Previously, when a user pressed CTRL+C to interrupt a running solve session, uncommitted changes were silently lost (or left uncommitted) and log files were not uploaded to the PR/issue even when `--attach-logs` was enabled. Additionally, the terminal showed "Claude command completed" instead of "Claude command interrupted".
+
+  Now on CTRL+C:
+  1. **Auto-commit**: Any uncommitted changes in the working directory are automatically committed and pushed to the branch before cleanup occurs.
+  2. **Log upload**: If `--attach-logs` is enabled, the log file is automatically uploaded to the GitHub PR/issue as a comment.
+  3. **Accurate message**: The terminal now correctly shows "Claude command interrupted" instead of "Claude command completed" when the process exits with code 130 (SIGINT).
+
+  Changes made:
+  - `src/exit-handler.lib.mjs`: Added optional `interrupt` parameter to `initializeExitHandler()`; SIGINT handler now calls it before cleanup, guarded against double invocation
+  - `src/solve.mjs`: Extended `cleanupContext` with branch/PR/owner/repo fields; new `interruptWrapper` auto-commits and uploads logs on CTRL+C
+  - `src/claude.lib.mjs`, `src/opencode.lib.mjs`, `src/codex.lib.mjs`, `src/agent.lib.mjs`: Detect exit code 130 and print "interrupted" instead of "completed"
+
+  Full case study analysis including timeline reconstruction, root cause analysis, and implementation details in `docs/case-studies/issue-1351/`.
+
+  fix: prevent false positive ready tag sync by using issue timeline API (Issue #1413)
+
+  Previously, `syncReadyTags()` used a GitHub full-text body search to find PRs linked to an issue:
+
+  ```js
+  gh pr list --search "in:body closes #1411 OR fixes #1411 OR resolves #1411"
+  ```
+
+  This caused a false positive: PR #843 matched because `1411` appeared as a source code line reference inside its body, not as a genuine issue-closing keyword.
+
+  Now uses the GitHub issue timeline API (`GET /repos/{owner}/{repo}/issues/{issue_number}/timeline`) to find PRs with genuine `cross-referenced` events, which is the same data GitHub uses to auto-close issues when PRs are merged.
+
+  fix: hide cancel button and show cancelling state on /merge cancel (Issue #1407)
+
+  When user clicked the "🛑 Cancel" button during `/merge` queue processing, the cancel button remained visible in the Telegram message until the current PR finished processing (potentially hours if waiting for CI). The toast message "The current PR will finish processing" was also confusing.
+
+  The fix immediately hides the cancel button by editing the message without `reply_markup`, shows a "🛑 Cancelling..." indicator in the progress message when cancellation is requested, and adds `isCancelled` support to `waitForCI()` for early exit when the operation is cancelled.
+
 ## 1.30.5
 
 ### Patch Changes

package/package.json

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

package/src/agent.lib.mjs

@@ -911,6 +911,9 @@ export const executeAgentCommand = async params => {
           // Explicit JSON error message from agent (Issue #1201: includes streaming-detected errors)
           errorInfo.message = `Agent reported error: ${outputError.match}`;
           await log(`\n\n❌ ${errorInfo.message}`, { level: 'error' });
+        } else if (exitCode === 130) {
+          errorInfo.message = 'Agent command interrupted (CTRL+C)';
+          await log('\n\n⚠️ Agent command interrupted (CTRL+C)');
         } else {
           errorInfo.message = `Agent command failed with exit code ${exitCode}`;
           await log(`\n\n❌ ${errorInfo.message}`, { level: 'error' });

package/src/agent.prompts.lib.mjs

@@ -212,7 +212,12 @@ Self review.
    - When you check your solution draft, run all tests locally.
    - When you check your solution draft, verify git status shows a clean working tree with no uncommitted changes.
    - When you compare with repo style, use gh pr diff [number].
-   - When you finalize, confirm code, tests, and description are consistent.
+   - When you finalize, confirm code, tests, and description are consistent.${
+     argv && argv.promptEnsureAllRequirementsAreMet
+       ? `
+   - When no explicit feedback or requirements is provided, ensure all changes are correct, consistent, validated, tested, logged and fully meet all discussed requirements (check issue description and all comments in issue and in pull request). Ensure all CI/CD checks pass.`
+       : ''
+   }
 
 GitHub CLI command patterns.
    - IMPORTANT: Always use --paginate flag when fetching lists from GitHub API to ensure all results are returned (GitHub returns max 30 per page by default).

package/src/claude.lib.mjs

@@ -1295,7 +1295,10 @@ export const executeClaudeCommand = async params => {
       }
       // Issue #1088: If error_during_execution occurred but command didn't fail,
       // log it as "Finished with errors" instead of pure success
-      if (errorDuringExecution) {
+      // Issue #1351: Distinguish interrupted sessions (exit code 130) from normal completion
+      if (exitCode === 130) {
+        await log('\n\n⚠️ Claude command interrupted (CTRL+C)');
+      } else if (errorDuringExecution) {
         await log('\n\n⚠️ Claude command finished with errors');
       } else {
         await log('\n\n✅ Claude command completed');

package/src/claude.prompts.lib.mjs

@@ -254,7 +254,12 @@ Self review.
    - When you check your solution draft, run all tests locally.
    - When you check your solution draft, verify git status shows a clean working tree with no uncommitted changes.
    - When you compare with repo style, use gh pr diff [number].
-   - When you finalize, confirm code, tests, and description are consistent.
+   - When you finalize, confirm code, tests, and description are consistent.${
+     argv && argv.promptEnsureAllRequirementsAreMet
+       ? `
+   - When no explicit feedback or requirements is provided, ensure all changes are correct, consistent, validated, tested, logged and fully meet all discussed requirements (check issue description and all comments in issue and in pull request). Ensure all CI/CD checks pass.`
+       : ''
+   }
 
 GitHub CLI command patterns.
    - IMPORTANT: Always use --paginate flag when fetching lists from GitHub API to ensure all results are returned (GitHub returns max 30 per page by default).

package/src/codex.lib.mjs

@@ -398,6 +398,8 @@ export const executeCodexCommand = async params => {
           for (const line of messageLines) {
             await log(line, { level: 'warning' });
           }
+        } else if (exitCode === 130) {
+          await log('\n\n⚠️ Codex command interrupted (CTRL+C)');
         } else {
           await log(`\n\n❌ Codex command failed with exit code ${exitCode}`, { level: 'error' });
         }

package/src/codex.prompts.lib.mjs

@@ -220,7 +220,12 @@ Self review.
    - When you check your solution draft, run all tests locally.
    - When you check your solution draft, verify git status shows a clean working tree with no uncommitted changes.
    - When you compare with repo style, use gh pr diff [number].
-   - When you finalize, confirm code, tests, and description are consistent.
+   - When you finalize, confirm code, tests, and description are consistent.${
+     argv && argv.promptEnsureAllRequirementsAreMet
+       ? `
+   - When no explicit feedback or requirements is provided, ensure all changes are correct, consistent, validated, tested, logged and fully meet all discussed requirements (check issue description and all comments in issue and in pull request). Ensure all CI/CD checks pass.`
+       : ''
+   }
 
 GitHub CLI command patterns.
    - IMPORTANT: Always use --paginate flag when fetching lists from GitHub API to ensure all results are returned (GitHub returns max 30 per page by default).

package/src/exit-handler.lib.mjs

@@ -25,17 +25,22 @@ let exitMessageShown = false;
 let getLogPathFunction = null;
 let logFunction = null;
 let cleanupFunction = null;
+let interruptFunction = null;
+let interruptHandlerRan = false;
 
 /**
  * Initialize the exit handler with required dependencies
  * @param {Function} getLogPath - Function that returns the current log path
  * @param {Function} log - Logging function
  * @param {Function} cleanup - Optional cleanup function to call on exit
+ * @param {Function} interrupt - Optional interrupt function to call on SIGINT/SIGTERM before cleanup
+ *                               (e.g., auto-commit uncommitted changes, upload logs)
  */
-export const initializeExitHandler = (getLogPath, log, cleanup = null) => {
+export const initializeExitHandler = (getLogPath, log, cleanup = null, interrupt = null) => {
   getLogPathFunction = getLogPath;
   logFunction = log;
   cleanupFunction = cleanup;
+  interruptFunction = interrupt;
 };
 
 /**
@@ -114,6 +119,15 @@ export const installGlobalExitHandlers = () => {
 
   // Handle SIGINT (CTRL+C)
   process.on('SIGINT', async () => {
+    // Run interrupt handler first (auto-commit, log upload, etc.) — guard against double invocation
+    if (interruptFunction && !interruptHandlerRan) {
+      interruptHandlerRan = true;
+      try {
+        await interruptFunction();
+      } catch {
+        // Ignore interrupt handler errors
+      }
+    }
     if (cleanupFunction) {
       try {
         await cleanupFunction();
@@ -208,4 +222,5 @@ export const installGlobalExitHandlers = () => {
  */
 export const resetExitHandler = () => {
   exitMessageShown = false;
+  interruptHandlerRan = false;
 };

package/src/github-merge-ready-sync.lib.mjs

@@ -0,0 +1,251 @@
+#!/usr/bin/env node
+/**
+ * GitHub Merge Ready Tag Sync Library
+ *
+ * Provides utilities for syncing 'ready' tags between linked PRs and issues,
+ * and for finding genuinely linked PRs via the GitHub issue timeline API.
+ * Split from github-merge.lib.mjs to maintain file size limits.
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/1413
+ */
+
+import { promisify } from 'util';
+import { exec as execCallback } from 'child_process';
+
+const exec = promisify(execCallback);
+
+import { extractLinkedIssueNumber } from './github-linking.lib.mjs';
+
+// READY_LABEL is also exported from github-merge.lib.mjs (which re-exports it from here)
+export const READY_LABEL = {
+  name: 'ready',
+  description: 'Is ready to be merged',
+  color: '0E8A16', // Green color
+};
+
+/**
+ * Add a label to a GitHub issue or pull request
+ * @param {'issue'|'pr'} type - Whether to add to issue or PR
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @param {number} number - Issue or PR number
+ * @param {string} labelName - Label name to add
+ * @param {boolean} verbose - Whether to log verbose output
+ * @returns {Promise<{success: boolean, error: string|null}>}
+ */
+async function addLabel(type, owner, repo, number, labelName, verbose = false) {
+  const cmd = type === 'issue' ? 'issue' : 'pr';
+  try {
+    await exec(`gh ${cmd} edit ${number} --repo ${owner}/${repo} --add-label "${labelName}"`);
+    if (verbose) console.log(`[VERBOSE] /merge: Added '${labelName}' label to ${type} #${number}`);
+    return { success: true, error: null };
+  } catch (error) {
+    if (verbose) console.log(`[VERBOSE] /merge: Failed to add label to ${type} #${number}: ${error.message}`);
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Get open PRs that are genuinely linked to an issue via GitHub's issue timeline.
+ *
+ * Issue #1413: This replaces the previous full-text body search approach which
+ * caused false positives. For example, a search for `fixes #1411` would incorrectly
+ * match PR #843 because its body contained the string `1411→` as a source code line
+ * number in a code snippet — not as an issue closing reference.
+ *
+ * The GitHub issue timeline API returns `cross-referenced` events for PRs that
+ * explicitly close the issue using GitHub's reserved keywords (fixes/closes/resolves).
+ * This is the same data GitHub uses to auto-close issues when PRs are merged, so
+ * it reliably identifies genuine closing references.
+ *
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @param {number} issueNumber - Issue number to find linked PRs for
+ * @param {boolean} verbose - Whether to log verbose output
+ * @returns {Promise<Array<{number: number, title: string}>>} Array of open PRs that close this issue
+ */
+export async function getLinkedPRsFromTimeline(owner, repo, issueNumber, verbose = false) {
+  try {
+    const { stdout: timelineJson } = await exec(`gh api repos/${owner}/${repo}/issues/${issueNumber}/timeline --paginate`);
+    const timeline = JSON.parse(timelineJson.trim() || '[]');
+
+    // Extract cross-referenced events where the source is an open PR
+    // (source.issue.pull_request != null means the source is a PR, not a plain issue)
+    const linkedPRNumbers = new Set();
+    const linkedPRs = [];
+
+    for (const event of timeline) {
+      if (event.event === 'cross-referenced' && event.source?.issue?.pull_request != null && event.source?.issue?.state === 'open') {
+        const prNumber = event.source.issue.number;
+        if (!linkedPRNumbers.has(prNumber)) {
+          linkedPRNumbers.add(prNumber);
+          linkedPRs.push({
+            number: prNumber,
+            title: event.source.issue.title || '',
+          });
+        }
+      }
+    }
+
+    if (verbose) {
+      console.log(`[VERBOSE] /merge: Issue #${issueNumber} has ${linkedPRs.length} genuinely linked open PR(s) via timeline`);
+      for (const pr of linkedPRs) {
+        console.log(`[VERBOSE] /merge:   PR #${pr.number}: ${pr.title}`);
+      }
+    }
+
+    return linkedPRs;
+  } catch (error) {
+    if (verbose) {
+      console.log(`[VERBOSE] /merge: Error fetching timeline for issue #${issueNumber}: ${error.message}`);
+    }
+    return [];
+  }
+}
+
+/**
+ * Sync 'ready' tags between linked pull requests and issues
+ *
+ * Issue #1367: Before building the merge queue, ensure that:
+ * 1. If a PR has 'ready' label and is clearly linked to an issue (via standard GitHub
+ *    keywords in the PR body/title), the issue also gets 'ready' label.
+ * 2. If an issue has 'ready' label and has a clearly linked open PR, the PR also gets
+ *    'ready' label.
+ *
+ * This ensures the final list of ready PRs reflects all ready work, regardless of
+ * where the 'ready' label was originally applied.
+ *
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @param {boolean} verbose - Whether to log verbose output
+ * @returns {Promise<{synced: number, errors: number, details: Array<Object>}>}
+ */
+export async function syncReadyTags(owner, repo, verbose = false) {
+  const synced = [];
+  const errors = [];
+
+  if (verbose) {
+    console.log(`[VERBOSE] /merge: Syncing 'ready' tags for ${owner}/${repo}...`);
+  }
+
+  try {
+    // Fetch open PRs with 'ready' label (including body for link detection)
+    const { stdout: prsJson } = await exec(`gh pr list --repo ${owner}/${repo} --label "${READY_LABEL.name}" --state open --json number,title,body,labels --limit 100`);
+    const readyPRs = JSON.parse(prsJson.trim() || '[]');
+
+    if (verbose) {
+      console.log(`[VERBOSE] /merge: Found ${readyPRs.length} open PRs with 'ready' label for tag sync`);
+    }
+
+    // Fetch open issues with 'ready' label
+    const { stdout: issuesJson } = await exec(`gh issue list --repo ${owner}/${repo} --label "${READY_LABEL.name}" --state open --json number,title --limit 100`);
+    const readyIssues = JSON.parse(issuesJson.trim() || '[]');
+
+    if (verbose) {
+      console.log(`[VERBOSE] /merge: Found ${readyIssues.length} open issues with 'ready' label for tag sync`);
+    }
+
+    // Build a set of issue numbers that already have 'ready'
+    const readyIssueNumbers = new Set(readyIssues.map(i => String(i.number)));
+
+    // Step 1: For each PR with 'ready', find linked issue and sync label to it
+    for (const pr of readyPRs) {
+      try {
+        const prBody = pr.body || '';
+        const linkedIssueNumber = extractLinkedIssueNumber(prBody);
+
+        if (!linkedIssueNumber) {
+          if (verbose) {
+            console.log(`[VERBOSE] /merge: PR #${pr.number} has no linked issue (no closing keyword in body)`);
+          }
+          continue;
+        }
+
+        if (readyIssueNumbers.has(String(linkedIssueNumber))) {
+          if (verbose) {
+            console.log(`[VERBOSE] /merge: Issue #${linkedIssueNumber} already has 'ready' label (linked from PR #${pr.number})`);
+          }
+          continue;
+        }
+
+        // Issue doesn't have 'ready' label yet - add it
+        if (verbose) {
+          console.log(`[VERBOSE] /merge: PR #${pr.number} has 'ready', adding to linked issue #${linkedIssueNumber}`);
+        }
+
+        const result = await addLabel('issue', owner, repo, linkedIssueNumber, READY_LABEL.name, verbose);
+        if (result.success) {
+          synced.push({ type: 'pr-to-issue', prNumber: pr.number, issueNumber: Number(linkedIssueNumber) });
+          // Mark this issue as now having 'ready' so we don't process it again
+          readyIssueNumbers.add(String(linkedIssueNumber));
+        } else {
+          errors.push({ type: 'pr-to-issue', prNumber: pr.number, issueNumber: Number(linkedIssueNumber), error: result.error });
+        }
+      } catch (err) {
+        if (verbose) {
+          console.log(`[VERBOSE] /merge: Error syncing label from PR #${pr.number}: ${err.message}`);
+        }
+        errors.push({ type: 'pr-to-issue', prNumber: pr.number, error: err.message });
+      }
+    }
+
+    // Build a set of PR numbers that already have 'ready'
+    const readyPRNumbers = new Set(readyPRs.map(p => String(p.number)));
+
+    // Step 2: For each issue with 'ready', find linked PRs and sync label to them
+    for (const issue of readyIssues) {
+      try {
+        // Issue #1413: Use the GitHub issue timeline API to find PRs that genuinely
+        // close this issue via closing keywords. This avoids false positives from
+        // full-text search, which can match PRs that contain the issue number as a
+        // source code line number (e.g. "1411→  await log(...)") rather than as a
+        // real closing reference.
+        const linkedPRs = await getLinkedPRsFromTimeline(owner, repo, issue.number, verbose);
+
+        for (const linkedPR of linkedPRs) {
+          if (readyPRNumbers.has(String(linkedPR.number))) {
+            if (verbose) {
+              console.log(`[VERBOSE] /merge: PR #${linkedPR.number} already has 'ready' label (linked from issue #${issue.number})`);
+            }
+            continue;
+          }
+
+          // PR doesn't have 'ready' label yet - add it
+          if (verbose) {
+            console.log(`[VERBOSE] /merge: Issue #${issue.number} has 'ready', adding to linked PR #${linkedPR.number}`);
+          }
+
+          const result = await addLabel('pr', owner, repo, linkedPR.number, READY_LABEL.name, verbose);
+          if (result.success) {
+            synced.push({ type: 'issue-to-pr', issueNumber: issue.number, prNumber: linkedPR.number });
+            // Mark this PR as now having 'ready'
+            readyPRNumbers.add(String(linkedPR.number));
+          } else {
+            errors.push({ type: 'issue-to-pr', issueNumber: issue.number, prNumber: linkedPR.number, error: result.error });
+          }
+        }
+      } catch (err) {
+        if (verbose) {
+          console.log(`[VERBOSE] /merge: Error syncing label from issue #${issue.number}: ${err.message}`);
+        }
+        errors.push({ type: 'issue-to-pr', issueNumber: issue.number, error: err.message });
+      }
+    }
+  } catch (error) {
+    if (verbose) {
+      console.log(`[VERBOSE] /merge: Error during tag sync: ${error.message}`);
+    }
+    errors.push({ type: 'fetch', error: error.message });
+  }
+
+  if (verbose) {
+    console.log(`[VERBOSE] /merge: Tag sync complete. Synced: ${synced.length}, Errors: ${errors.length}`);
+  }
+
+  return {
+    synced: synced.length,
+    errors: errors.length,
+    details: synced,
+    errorDetails: errors,
+  };
+}