@link-assistant/hive-mind 1.26.0 → 1.26.2

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @link-assistant/hive-mind
 
+## 1.26.2
+
+### Patch Changes
+
+- 72c933c: Skip empty Claude subsection headers when auth error occurs in /limits output
+
+## 1.26.1
+
+### Patch Changes
+
+- 278415a: fix: post "Ready to merge" comment after auto-restart sequence with --auto-restart-until-mergeable (Issue #1371)
+
+  When `--auto-restart-until-mergeable` was used after a regular auto-restart sequence (triggered by uncommitted changes), the "Ready to merge" comment was silently suppressed because `checkForExistingComment` found a matching comment from a previous `solve` run.
+
+  The deduplication logic in `watchUntilMergeable` now uses an in-memory flag (`readyToMergeCommentPosted`) scoped to the current session, rather than searching all PR comment history. This correctly prevents duplicate comments within a single run while allowing new notifications when a fresh `solve` invocation starts.
+
 ## 1.26.0
 
 ### Minor Changes

package/README.md

@@ -46,7 +46,7 @@ For detailed features and comparisons, see [docs/FEATURES.md](./docs/FEATURES.md
 
 It is UNSAFE to run this software on your developer machine.
 
-It is recommended to use SEPARATE Ubuntu 24.04 installation (installation script is prepared for you).
+It is recommended to use Docker for installation (both locally and on servers). See the [Docker installation](#using-docker) section below.
 
 This software uses full autonomous mode of Claude Code, that means it is free to execute any commands it sees fit.
 
@@ -292,121 +292,26 @@ See [docs/HELM.md](./docs/HELM.md) for detailed Helm configuration options.
 
 **Note:** The Helm chart is published to [ArtifactHub](https://artifacthub.io/packages/helm/link-assistant/hive-mind) for easy discovery.
 
-### Installation on Ubuntu 24.04 server
+### Installation on Ubuntu 24.04 server (Deprecated)
 
-1. Reset/install VPS/VDS server with fresh Ubuntu 24.04
-2. Login to `root` user.
-3. Execute main installation script
-
-   ```bash
-   curl -fsSL -o- https://github.com/link-assistant/hive-mind/raw/refs/heads/main/scripts/ubuntu-24-server-install.sh | bash
-   ```
-
-   **Note:** The installation script will NOT run `gh auth login` automatically. This is intentional to support Docker builds without timeouts. Authentication is performed in the next steps.
-
-4. Login to `hive` user
-
-   ```bash
-   su - hive
-   ```
-
-5. **IMPORTANT:** Authenticate with GitHub CLI AFTER installation is complete
-
-   ```bash
-   gh-setup-git-identity
-   ```
-
-   Note: Follow the prompts to authenticate with your GitHub account. This is required for the gh tool to work, and the system will perform all actions using this GitHub account. This step must be done AFTER the installation script completes to avoid build timeouts in Docker environments.
-
-6. Claude Code CLI, OpenCode AI CLI, and @link-assistant/agent are preinstalled with the previous script. Now you need to make sure claude is authorized. Execute claude command, and follow all steps to authorize the local claude
-
-   ```bash
-   claude
-   ```
-
-   Note: Both opencode and agent come with free Grok Code Fast 1 model by default - so no authorization is required for these tools.
-
-7. Launch the Hive Mind telegram bot:
-
-   **Using Links Notation (recommended):**
-
-   ```
-   screen -R bot # Enter new screen for bot
-
-   hive-telegram-bot --configuration "
-     TELEGRAM_BOT_TOKEN: '849...355:AAG...rgk_YZk...aPU'
-     TELEGRAM_ALLOWED_CHATS:
-       -1002975819706
-       -1002861722681
-     TELEGRAM_HIVE_OVERRIDES:
-       --all-issues
-       --once
-       --skip-issues-with-prs
-       --attach-logs
-       --verbose
-       --no-tool-check
-     TELEGRAM_SOLVE_OVERRIDES:
-       --attach-logs
-       --verbose
-       --no-tool-check
-     TELEGRAM_BOT_VERBOSE: true
-   "
-
-   # Press CTRL + A + D for detach from screen
-   ```
-
-   **Using individual command-line options:**
-
-   ```
-   screen -R bot # Enter new screen for bot
-
-   hive-telegram-bot --token 849...355:AAG...rgk_YZk...aPU --allowed-chats "(
-     -1002975819706
-     -1002861722681
-   )" --hive-overrides "(
-     --all-issues
-     --once
-     --skip-issues-with-prs
-     --attach-logs
-     --verbose
-     --no-tool-check
-   )" --solve-overrides "(
-     --attach-logs
-     --verbose
-     --no-tool-check
-   )" --verbose
-
-   # Press CTRL + A + D for detach from screen
-   ```
-
-   Note: You may need to register you own bot with https://t.me/BotFather to get the bot token.
-
-#### Codex sign-in
-
-1. Connect to your instance of VPS with Hive Mind installed, using SSH with tunnel opened
-
-```bash
-ssh -L 1455:localhost:1455 root@123.123.123.123
-```
-
-2. Start codex login oAuth server:
-
-```bash
-codex login
-```
-
-The oAuth callback server on 1455 port will be started, and the link to oAuth will be printed, copy the link.
-
-3. Use your browser on machine where you started the tunnel from, paste there the link from `codex login` command, and go there using your browser. Once redirected to localhost:1455 you will see successful login page, and in `codex login` you will see `Successfully logged in`. After that `codex login` command will complete, and you can use `codex` command as usual to verify. It should also be working with `--tool codex` in `solve` and `hive` commands.
+> ⚠️ **DEPRECATED:** This installation method is no longer recommended.
+>
+> **We now recommend using Docker for all installations**, both on developer machines and servers.
+> Docker provides better isolation, easier management, and consistent environments.
+>
+> Please use the [Docker installation method](#using-docker) above.
+> For Kubernetes deployments, see the [Helm installation](#helm-installation-kubernetes) section.
+>
+> The legacy bare-metal installation instructions have been moved to [docs/UBUNTU-SERVER.md](./docs/UBUNTU-SERVER.md) for reference.
 
 ### Core Operations
 
 ```bash
 # Solve using maximum power
-solve https://github.com/Veronika89-lang/index.html/issues/1 --auto-continue --attach-logs --verbose --model opus --auto-fork --think max
+solve https://github.com/Veronika89-lang/index.html/issues/1 --auto-continue --attach-logs --verbose --model opus --think max
 
-# Solve GitHub issues automatically (auto-fork if no write access)
-solve https://github.com/owner/repo/issues/123 --auto-fork --model sonnet
+# Solve GitHub issues automatically
+solve https://github.com/owner/repo/issues/123 --model sonnet
 
 # Solve issue with PR to custom branch (manual fork mode)
 solve https://github.com/owner/repo/issues/123 --base-branch develop --fork
@@ -420,8 +325,8 @@ solve https://github.com/owner/repo/issues/123 --resume session-id
 # Start hive orchestration (monitor and solve issues automatically)
 hive https://github.com/owner/repo --monitor-tag "help wanted" --concurrency 3
 
-# Monitor all issues in organization with auto-fork
-hive https://github.com/microsoft --all-issues --max-issues 10 --auto-fork
+# Monitor all issues in organization
+hive https://github.com/microsoft --all-issues --max-issues 10
 
 # Run collaborative review process
 review --repo owner/repo --pr 456
@@ -440,8 +345,6 @@ review --repo owner/repo --pr 456
 | `reviewers-hive.mjs` (alpha / experimental) | Review team management        | Multi-agent consensus, reviewer assignment                               |
 | `telegram-bot.mjs` (stable)                 | Telegram bot interface        | Remote command execution, group chat support, diagnostic tools           |
 
-> **Note**: For a comprehensive analysis of the "Could not process image" error in AI issue solvers, see the [Case Study: Issue #597](docs/case-studies/issue-597/README.md). The case study includes root cause analysis, timeline reconstruction, and evidence of GitHub's time-limited S3 URLs causing image processing failures. Separate tools for downloading GitHub issues and PRs with embedded images are being developed at [gh-download-issue](https://github.com/link-foundation/gh-download-issue) and [gh-download-pull-request](https://github.com/link-foundation/gh-download-pull-request).
-
 ## 🔧 solve Options
 
 ```bash
@@ -715,8 +618,8 @@ sequenceDiagram
 ### Automated Issue Resolution
 
 ```bash
-# Auto-fork and solve issue (automatic fork detection for public repos)
-solve https://github.com/owner/repo/issues/123 --auto-fork --model opus
+# Solve issue (automatically forks if no write access)
+solve https://github.com/owner/repo/issues/123 --model opus
 
 # Manual fork and solve issue (works for both public and private repos)
 solve https://github.com/owner/repo/issues/123 --fork --model opus
@@ -737,17 +640,17 @@ solve https://github.com/owner/repo/issues/123 --dry-run
 # Monitor single repository with specific label
 hive https://github.com/owner/repo --monitor-tag "bug" --concurrency 4
 
-# Monitor all issues in an organization with auto-fork
-hive https://github.com/microsoft --all-issues --max-issues 20 --once --auto-fork
+# Monitor all issues in an organization
+hive https://github.com/microsoft --all-issues --max-issues 20 --once
 
 # Monitor user repositories with high concurrency
-hive https://github.com/username --all-issues --concurrency 8 --interval 120 --auto-fork
+hive https://github.com/username --all-issues --concurrency 8 --interval 120
 
 # Skip issues that already have PRs
 hive https://github.com/org/repo --skip-issues-with-prs --verbose
 
-# Auto-cleanup temporary files and auto-fork if needed
-hive https://github.com/org/repo --auto-cleanup --auto-fork --concurrency 5
+# Auto-cleanup temporary files
+hive https://github.com/org/repo --auto-cleanup --concurrency 5
 ```
 
 ### Session Management

package/package.json

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

package/src/limits.lib.mjs

@@ -700,177 +700,184 @@ export function calculateTimePassedPercentage(resetsAt, periodHours) {
  * @param {Object} cpuLoad - Optional CPU load info from getCpuLoadInfo
  * @param {Object} memory - Optional memory info from getMemoryInfo
  * @param {string|null} claudeError - Optional error message to show in Claude sections (e.g., auth expired)
- * @returns {string} Formatted message
+ * @param {string[]} extraSections - Optional extra sections to append inside the code block (e.g. queue status)
+ * @returns {string} Formatted message wrapped in a single code block
  * @see https://github.com/link-assistant/hive-mind/issues/1242
  */
-export function formatUsageMessage(usage, diskSpace = null, githubRateLimit = null, cpuLoad = null, memory = null, claudeError = null) {
-  // Use code block for monospace font to align progress bars properly
-  let message = '```\n';
+export function formatUsageMessage(usage, diskSpace = null, githubRateLimit = null, cpuLoad = null, memory = null, claudeError = null, extraSections = []) {
+  // Build sections as individual text blocks; they will all be joined and wrapped in a
+  // single code block at the end. This avoids fragile string-searching to inject content.
+
+  const sections = [];
 
   // Show current time
-  message += `Current time: ${formatCurrentTime()}\n\n`;
+  sections.push(`Current time: ${formatCurrentTime()}\n`);
 
   // CPU load section (if provided)
   // Threshold: Blocks new commands when usage >= 65%
   if (cpuLoad) {
-    message += 'CPU\n';
+    let section = 'CPU\n';
     const usedBar = getProgressBar(cpuLoad.usagePercentage, DISPLAY_THRESHOLDS.CPU);
     // Show 'used' label when below threshold, warning emoji when at/above threshold
     // See: https://github.com/link-assistant/hive-mind/issues/1267
     const suffix = cpuLoad.usagePercentage >= DISPLAY_THRESHOLDS.CPU ? ' ⚠️' : ' used';
-    message += `${usedBar} ${cpuLoad.usagePercentage}%${suffix}\n`;
+    section += `${usedBar} ${cpuLoad.usagePercentage}%${suffix}\n`;
     // Show cores used based on 5m load average (e.g., "0.04/6 CPU cores used" or "3/6 CPU cores used")
     // Use parseFloat to strip unnecessary trailing zeros (3.00 -> 3, 0.10 -> 0.1, 0.04 -> 0.04)
-    message += `${parseFloat(cpuLoad.loadAvg5.toFixed(2))}/${cpuLoad.cpuCount} CPU cores\n\n`;
+    section += `${parseFloat(cpuLoad.loadAvg5.toFixed(2))}/${cpuLoad.cpuCount} CPU cores\n`;
+    sections.push(section);
   }
 
   // Memory section (if provided)
   // Threshold: Blocks new commands when usage >= 65%
   if (memory) {
-    message += 'RAM\n';
+    let section = 'RAM\n';
     const usedBar = getProgressBar(memory.usedPercentage, DISPLAY_THRESHOLDS.RAM);
     const suffix = memory.usedPercentage >= DISPLAY_THRESHOLDS.RAM ? ' ⚠️' : ' used';
-    message += `${usedBar} ${memory.usedPercentage}%${suffix}\n`;
-    message += `${formatBytesRange(memory.usedBytes, memory.totalBytes)}\n\n`;
+    section += `${usedBar} ${memory.usedPercentage}%${suffix}\n`;
+    section += `${formatBytesRange(memory.usedBytes, memory.totalBytes)}\n`;
+    sections.push(section);
   }
 
   // Disk space section (if provided)
   // Threshold: One-at-a-time mode when usage >= 90%
   if (diskSpace) {
-    message += 'Disk space\n';
+    let section = 'Disk space\n';
     // Show used percentage with progress bar and threshold marker
     const usedBar = getProgressBar(diskSpace.usedPercentage, DISPLAY_THRESHOLDS.DISK);
     const suffix = diskSpace.usedPercentage >= DISPLAY_THRESHOLDS.DISK ? ' ⚠️' : ' used';
-    message += `${usedBar} ${diskSpace.usedPercentage}%${suffix}\n`;
-    message += `${formatBytesRange(diskSpace.usedBytes, diskSpace.totalBytes)}\n\n`;
+    section += `${usedBar} ${diskSpace.usedPercentage}%${suffix}\n`;
+    section += `${formatBytesRange(diskSpace.usedBytes, diskSpace.totalBytes)}\n`;
+    sections.push(section);
   }
 
   // GitHub API rate limits section (if provided)
   // Threshold: Blocks parallel claude commands when >= 75%
   if (githubRateLimit) {
-    message += 'GitHub API\n';
+    let section = 'GitHub API\n';
     // Show used percentage with progress bar and threshold marker
     const usedBar = getProgressBar(githubRateLimit.usedPercentage, DISPLAY_THRESHOLDS.GITHUB_API);
     const suffix = githubRateLimit.usedPercentage >= DISPLAY_THRESHOLDS.GITHUB_API ? ' ⚠️' : ' used';
-    message += `${usedBar} ${githubRateLimit.usedPercentage}%${suffix}\n`;
-    message += `${githubRateLimit.used}/${githubRateLimit.limit} requests\n`;
+    section += `${usedBar} ${githubRateLimit.usedPercentage}%${suffix}\n`;
+    section += `${githubRateLimit.used}/${githubRateLimit.limit} requests\n`;
     if (githubRateLimit.relativeReset) {
-      message += `Resets in ${githubRateLimit.relativeReset} (${githubRateLimit.resetTime})\n`;
+      section += `Resets in ${githubRateLimit.relativeReset} (${githubRateLimit.resetTime})\n`;
     } else if (githubRateLimit.resetTime) {
-      message += `Resets ${githubRateLimit.resetTime}\n`;
+      section += `Resets ${githubRateLimit.resetTime}\n`;
     }
-    message += '\n';
+    sections.push(section);
   }
 
   // Claude limits section
-  // When there's an error (e.g., auth expired), show it once here instead of repeating in each subsection
-  if (claudeError) {
-    message += `Claude limits\n${claudeError}\n\n`;
-  }
-
-  // Claude 5 hour session (five_hour)
-  // Threshold: One-at-a-time mode when usage >= 65%
-  message += 'Claude 5 hour session\n';
+  // When there's an error (e.g., auth expired), show it once and skip empty subsections
   if (claudeError) {
-    // Error already shown above; skip subsection content
-  } else if (usage && usage.currentSession.percentage !== null) {
-    // Add time passed progress bar first (no threshold marker for time)
-    const timePassed = calculateTimePassedPercentage(usage.currentSession.resetsAt, 5);
-    if (timePassed !== null) {
-      const timeBar = getProgressBar(timePassed);
-      message += `${timeBar} ${timePassed}% passed\n`;
-    }
+    sections.push(`Claude limits\n${claudeError}\n`);
+  } else {
+    // Claude 5 hour session (five_hour)
+    // Threshold: One-at-a-time mode when usage >= 65%
+    let sessionSection = 'Claude 5 hour session\n';
+    if (usage && usage.currentSession.percentage !== null) {
+      // Add time passed progress bar first (no threshold marker for time)
+      const timePassed = calculateTimePassedPercentage(usage.currentSession.resetsAt, 5);
+      if (timePassed !== null) {
+        const timeBar = getProgressBar(timePassed);
+        sessionSection += `${timeBar} ${timePassed}% passed\n`;
+      }
 
-    // Add usage progress bar second with threshold marker
-    // Use Math.floor so 100% only appears when usage is exactly 100%
-    // See: https://github.com/link-assistant/hive-mind/issues/1133
-    const pct = Math.floor(usage.currentSession.percentage);
-    const bar = getProgressBar(pct, DISPLAY_THRESHOLDS.CLAUDE_5_HOUR_SESSION);
-    const suffix = pct >= DISPLAY_THRESHOLDS.CLAUDE_5_HOUR_SESSION ? ' ⚠️' : ' used';
-    message += `${bar} ${pct}%${suffix}\n`;
-
-    if (usage.currentSession.resetTime) {
-      const relativeTime = formatRelativeTime(usage.currentSession.resetsAt);
-      if (relativeTime) {
-        message += `Resets in ${relativeTime} (${usage.currentSession.resetTime})\n`;
-      } else {
-        message += `Resets ${usage.currentSession.resetTime}\n`;
+      // Add usage progress bar second with threshold marker
+      // Use Math.floor so 100% only appears when usage is exactly 100%
+      // See: https://github.com/link-assistant/hive-mind/issues/1133
+      const pct = Math.floor(usage.currentSession.percentage);
+      const bar = getProgressBar(pct, DISPLAY_THRESHOLDS.CLAUDE_5_HOUR_SESSION);
+      const suffix = pct >= DISPLAY_THRESHOLDS.CLAUDE_5_HOUR_SESSION ? ' ⚠️' : ' used';
+      sessionSection += `${bar} ${pct}%${suffix}\n`;
+
+      if (usage.currentSession.resetTime) {
+        const relativeTime = formatRelativeTime(usage.currentSession.resetsAt);
+        if (relativeTime) {
+          sessionSection += `Resets in ${relativeTime} (${usage.currentSession.resetTime})\n`;
+        } else {
+          sessionSection += `Resets ${usage.currentSession.resetTime}\n`;
+        }
       }
+    } else {
+      sessionSection += 'N/A\n';
     }
-  } else {
-    message += 'N/A\n';
-  }
-  message += '\n';
+    sections.push(sessionSection);
+
+    // Current week (all models / seven_day)
+    // Threshold: One-at-a-time mode when usage >= 97%
+    let allModelsSection = 'Current week (all models)\n';
+    if (usage && usage.allModels.percentage !== null) {
+      // Add time passed progress bar first (no threshold marker for time)
+      const timePassed = calculateTimePassedPercentage(usage.allModels.resetsAt, 168);
+      if (timePassed !== null) {
+        const timeBar = getProgressBar(timePassed);
+        allModelsSection += `${timeBar} ${timePassed}% passed\n`;
+      }
 
-  // Current week (all models / seven_day)
-  // Threshold: One-at-a-time mode when usage >= 97%
-  message += 'Current week (all models)\n';
-  if (claudeError) {
-    // Error already shown above; skip subsection content
-  } else if (usage && usage.allModels.percentage !== null) {
-    // Add time passed progress bar first (no threshold marker for time)
-    const timePassed = calculateTimePassedPercentage(usage.allModels.resetsAt, 168);
-    if (timePassed !== null) {
-      const timeBar = getProgressBar(timePassed);
-      message += `${timeBar} ${timePassed}% passed\n`;
+      // Add usage progress bar second with threshold marker
+      // Use Math.floor so 100% only appears when usage is exactly 100%
+      // See: https://github.com/link-assistant/hive-mind/issues/1133
+      const pct = Math.floor(usage.allModels.percentage);
+      const bar = getProgressBar(pct, DISPLAY_THRESHOLDS.CLAUDE_WEEKLY);
+      const suffix = pct >= DISPLAY_THRESHOLDS.CLAUDE_WEEKLY ? ' ⚠️' : ' used';
+      allModelsSection += `${bar} ${pct}%${suffix}\n`;
+
+      if (usage.allModels.resetTime) {
+        const relativeTime = formatRelativeTime(usage.allModels.resetsAt);
+        if (relativeTime) {
+          allModelsSection += `Resets in ${relativeTime} (${usage.allModels.resetTime})\n`;
+        } else {
+          allModelsSection += `Resets ${usage.allModels.resetTime}\n`;
+        }
+      }
+    } else {
+      allModelsSection += 'N/A\n';
     }
+    sections.push(allModelsSection);
+
+    // Current week (Sonnet only / seven_day_sonnet)
+    // Threshold: One-at-a-time mode when usage >= 97% (same as all models)
+    let sonnetSection = 'Current week (Sonnet only)\n';
+    if (usage && usage.sonnetOnly.percentage !== null) {
+      // Add time passed progress bar first (no threshold marker for time)
+      const timePassed = calculateTimePassedPercentage(usage.sonnetOnly.resetsAt, 168);
+      if (timePassed !== null) {
+        const timeBar = getProgressBar(timePassed);
+        sonnetSection += `${timeBar} ${timePassed}% passed\n`;
+      }
 
-    // Add usage progress bar second with threshold marker
-    // Use Math.floor so 100% only appears when usage is exactly 100%
-    // See: https://github.com/link-assistant/hive-mind/issues/1133
-    const pct = Math.floor(usage.allModels.percentage);
-    const bar = getProgressBar(pct, DISPLAY_THRESHOLDS.CLAUDE_WEEKLY);
-    const suffix = pct >= DISPLAY_THRESHOLDS.CLAUDE_WEEKLY ? ' ⚠️' : ' used';
-    message += `${bar} ${pct}%${suffix}\n`;
-
-    if (usage.allModels.resetTime) {
-      const relativeTime = formatRelativeTime(usage.allModels.resetsAt);
-      if (relativeTime) {
-        message += `Resets in ${relativeTime} (${usage.allModels.resetTime})\n`;
-      } else {
-        message += `Resets ${usage.allModels.resetTime}\n`;
+      // Add usage progress bar second with threshold marker
+      // Use Math.floor so 100% only appears when usage is exactly 100%
+      // See: https://github.com/link-assistant/hive-mind/issues/1133
+      const pct = Math.floor(usage.sonnetOnly.percentage);
+      const bar = getProgressBar(pct, DISPLAY_THRESHOLDS.CLAUDE_WEEKLY);
+      const suffix = pct >= DISPLAY_THRESHOLDS.CLAUDE_WEEKLY ? ' ⚠️' : ' used';
+      sonnetSection += `${bar} ${pct}%${suffix}\n`;
+
+      if (usage.sonnetOnly.resetTime) {
+        const relativeTime = formatRelativeTime(usage.sonnetOnly.resetsAt);
+        if (relativeTime) {
+          sonnetSection += `Resets in ${relativeTime} (${usage.sonnetOnly.resetTime})\n`;
+        } else {
+          sonnetSection += `Resets ${usage.sonnetOnly.resetTime}\n`;
+        }
       }
+    } else {
+      sonnetSection += 'N/A\n';
     }
-  } else {
-    message += 'N/A\n';
+    sections.push(sonnetSection);
   }
-  message += '\n';
 
-  // Current week (Sonnet only / seven_day_sonnet)
-  // Threshold: One-at-a-time mode when usage >= 97% (same as all models)
-  message += 'Current week (Sonnet only)\n';
-  if (claudeError) {
-    // Error already shown above; skip subsection content
-  } else if (usage && usage.sonnetOnly.percentage !== null) {
-    // Add time passed progress bar first (no threshold marker for time)
-    const timePassed = calculateTimePassedPercentage(usage.sonnetOnly.resetsAt, 168);
-    if (timePassed !== null) {
-      const timeBar = getProgressBar(timePassed);
-      message += `${timeBar} ${timePassed}% passed\n`;
-    }
-
-    // Add usage progress bar second with threshold marker
-    // Use Math.floor so 100% only appears when usage is exactly 100%
-    // See: https://github.com/link-assistant/hive-mind/issues/1133
-    const pct = Math.floor(usage.sonnetOnly.percentage);
-    const bar = getProgressBar(pct, DISPLAY_THRESHOLDS.CLAUDE_WEEKLY);
-    const suffix = pct >= DISPLAY_THRESHOLDS.CLAUDE_WEEKLY ? ' ⚠️' : ' used';
-    message += `${bar} ${pct}%${suffix}\n`;
-
-    if (usage.sonnetOnly.resetTime) {
-      const relativeTime = formatRelativeTime(usage.sonnetOnly.resetsAt);
-      if (relativeTime) {
-        message += `Resets in ${relativeTime} (${usage.sonnetOnly.resetTime})\n`;
-      } else {
-        message += `Resets ${usage.sonnetOnly.resetTime}\n`;
-      }
-    }
-  } else {
-    message += 'N/A\n';
+  // Append any caller-provided extra sections (e.g. queue status) inside the code block
+  for (const extra of extraSections) {
+    sections.push(extra);
   }
 
-  message += '```';
-  return message;
+  // Wrap all sections in a single code block for monospace font / aligned progress bars.
+  // Sections are separated by blank lines; the trailing newline on each section provides spacing.
+  return '```\n' + sections.join('\n') + '```';
 }
 
 // ============================================================================

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

@@ -345,6 +345,13 @@ export const watchUntilMergeable = async params => {
   // `restartCount` counts actual AI tool executions (when we actually restart the AI)
   let restartCount = 0;
 
+  // Issue #1371: Track whether a "Ready to merge" comment was posted in THIS session.
+  // This replaces the all-time history check (checkForExistingComment) which incorrectly
+  // suppressed new notifications when a previous solve run had already posted one.
+  // In-memory deduplication correctly handles the case where multiple check cycles in
+  // the same run detect mergeability simultaneously, without blocking fresh runs.
+  let readyToMergeCommentPosted = false;
+
   let currentBackoffSeconds = watchInterval;
 
   await log('');
@@ -430,18 +437,19 @@ export const watchUntilMergeable = async params => {
           await log(formatAligned('', 'PR is ready to be merged manually', '', 2));
           await log(formatAligned('', 'Exiting auto-restart-until-mergeable mode', '', 2));
 
-          // Issue #1323: Post success comment only if one doesn't already exist
-          // This prevents duplicate comments when multiple processes reach this point
+          // Issue #1371: Post success comment only if not already posted in this session.
+          // Use in-memory flag instead of checking all PR comment history (issue #1323),
+          // since the historical check incorrectly suppressed notifications when a
+          // previous solve run had already posted a "Ready to merge" comment.
           try {
-            const readyToMergeSignature = '## ✅ Ready to merge';
-            const hasExistingComment = await checkForExistingComment(owner, repo, prNumber, readyToMergeSignature, argv.verbose);
-            if (!hasExistingComment) {
+            if (!readyToMergeCommentPosted) {
               // Issue #1345: Differentiate message when no CI is configured
               const ciLine = noCiConfigured ? '- No CI/CD checks are configured for this repository' : '- All CI checks have passed';
               const commentBody = `## ✅ Ready to merge\n\nThis pull request is now ready to be merged:\n${ciLine}\n- No merge conflicts\n- No pending changes\n\n---\n*Monitored by hive-mind with --auto-restart-until-mergeable flag*`;
               await $`gh pr comment ${prNumber} --repo ${owner}/${repo} --body ${commentBody}`;
+              readyToMergeCommentPosted = true;
             } else {
-              await log(formatAligned('', 'Skipping duplicate "Ready to merge" comment', '', 2));
+              await log(formatAligned('', 'Skipping duplicate "Ready to merge" comment (already posted this session)', '', 2));
             }
           } catch {
             // Don't fail if comment posting fails

package/src/telegram-bot.mjs

@@ -785,17 +785,14 @@ bot.command('limits', async ctx => {
   // while still displaying all other limits sections (disk, GitHub, CPU, memory)
   // See: https://github.com/link-assistant/hive-mind/issues/1343
   const claudeError = limits.claude.success ? null : limits.claude.error;
-  let message = '📊 *Usage Limits*\n\n' + formatUsageMessage(limits.claude.success ? limits.claude.usage : null, limits.disk.success ? limits.disk.diskSpace : null, limits.github.success ? limits.github.githubRateLimit : null, limits.cpu.success ? limits.cpu.cpuLoad : null, limits.memory.success ? limits.memory.memory : null, claudeError);
   const solveQueue = getSolveQueue({ verbose: VERBOSE });
-  // Insert per-queue status into the code block
-  // Shows each queue (claude, agent) with pending/processing counts
-  // Processing counts are actual running system processes (via pgrep)
+  // Fetch queue status and pass it as an extra section to formatUsageMessage so that all
+  // sections are assembled before the code block is formed — no fragile string-searching needed.
+  // Shows each queue (claude, agent) with pending/processing counts.
+  // Processing counts are actual running system processes (via pgrep).
   // See: https://github.com/link-assistant/hive-mind/issues/1267
-  const codeBlockEnd = message.lastIndexOf('```');
-  if (codeBlockEnd !== -1) {
-    const queueStatus = await solveQueue.formatStatus();
-    message = message.slice(0, codeBlockEnd) + `\n${queueStatus}` + message.slice(codeBlockEnd);
-  }
+  const queueStatus = await solveQueue.formatStatus();
+  const message = '📊 *Usage Limits*\n\n' + formatUsageMessage(limits.claude.success ? limits.claude.usage : null, limits.disk.success ? limits.disk.diskSpace : null, limits.github.success ? limits.github.githubRateLimit : null, limits.cpu.success ? limits.cpu.cpuLoad : null, limits.memory.success ? limits.memory.memory : null, claudeError, [queueStatus]);
   await ctx.telegram.editMessageText(fetchingMessage.chat.id, fetchingMessage.message_id, undefined, message, { parse_mode: 'Markdown' });
 });
 bot.command('version', async ctx => {