@link-assistant/hive-mind 2.11.7 → 2.11.9

package/src/locales/ru.lino

@@ -658,6 +658,16 @@ ru
       label "Длительность"
     session
       label "Сеанс"
+      recovered
+        oom "восстановлено после нехватки памяти"
+        kill "восстановлено после принудительного завершения"
+        at "Событие зафиксировано в {{observedAt}}; рабочая сессия продолжилась и завершилась."
+        resumed "Для восстановления после завершения запущена новая рабочая сессия."
+      kill
+        cause "Причина"
+        diagnostics "Диагностика завершения"
+        resumed "🔄 Запущена новая рабочая сессия для восстановления после этого завершения: {{sessionId}}"
+        resumed_attempt "🔄 Запущена новая рабочая сессия для восстановления после этого завершения (попытка {{attempt}}): {{sessionId}}"
     isolation
       label "Изоляция"
     error

package/src/locales/zh.lino

@@ -658,6 +658,16 @@ zh
       label "耗时"
     session
       label "会话"
+      recovered
+        oom "已从内存不足中恢复"
+        kill "已从强制终止中恢复"
+        at "事件发生于 {{observedAt}}；工作会话继续运行并已完成。"
+        resumed "已启动新的工作会话以从终止中恢复。"
+      kill
+        cause "原因"
+        diagnostics "终止诊断"
+        resumed "🔄 已启动新的工作会话以从此次终止中恢复：{{sessionId}}"
+        resumed_attempt "🔄 已启动新的工作会话以从此次终止中恢复（第 {{attempt}} 次尝试）：{{sessionId}}"
     isolation
       label "隔离"
     error

package/src/log-growth.lib.mjs

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+
+/**
+ * Notice a session log that is running away (issue #2135).
+ *
+ * The log captured for that issue reached 286 MB / 1,354,845 lines because a
+ * single `gh pr diff` answer was mirrored to stdout, copied into the session
+ * log by the stdio interceptor, committed as the development log, and so
+ * included in the *next* run's diff - each round bigger than the last. Nothing
+ * said a word about it until the solve process died on the V8 heap limit.
+ *
+ * This module keeps a running count of the bytes written to the log and hands
+ * back a warning the first time the total crosses each threshold, so the log
+ * itself carries the evidence of its own growth.
+ *
+ * @module log-growth
+ */
+
+const MEGABYTE = 1024 * 1024;
+
+/**
+ * Sizes a session log has no business reaching.
+ *
+ * A busy solve session writes single-digit megabytes; the captured runaway
+ * session was two orders of magnitude past that. Warning three times (rather
+ * than once) keeps the trail readable: the distance between the warnings says
+ * how fast the log is growing.
+ */
+export const LOG_GROWTH_THRESHOLDS = [64 * MEGABYTE, 256 * MEGABYTE, 1024 * MEGABYTE];
+
+const formatBytes = bytes => {
+  if (bytes >= 1024 * MEGABYTE) return `${(bytes / (1024 * MEGABYTE)).toFixed(1)} GB`;
+  if (bytes >= MEGABYTE) return `${(bytes / MEGABYTE).toFixed(1)} MB`;
+  return `${(bytes / 1024).toFixed(1)} KB`;
+};
+
+/**
+ * Create an independent growth tracker.
+ *
+ * @param {object} [params]
+ * @param {number[]} [params.thresholds] - ascending byte counts to warn at.
+ * @returns {{record: (bytes: number) => string|null, reset: () => void, total: () => number}}
+ *   `record` returns a warning message the first time the running total reaches
+ *   the next threshold, and null otherwise.
+ */
+export const createLogGrowthTracker = ({ thresholds = LOG_GROWTH_THRESHOLDS } = {}) => {
+  let total = 0;
+  let nextIndex = 0;
+
+  return {
+    record(bytes) {
+      if (!Number.isFinite(bytes) || bytes <= 0) return null;
+      total += bytes;
+      if (nextIndex >= thresholds.length || total < thresholds[nextIndex]) return null;
+
+      // Skip past every threshold this write blew through, so a single huge
+      // append produces one warning naming the size actually reached.
+      while (nextIndex < thresholds.length && total >= thresholds[nextIndex]) nextIndex += 1;
+
+      return `⚠️  Session log has grown to ${formatBytes(total)}. Something is writing very large output into it - mirrored command output (for example a "gh pr diff" of a branch that has logs committed to it) is the usual cause. See docs/case-studies/issue-2135.`;
+    },
+    reset() {
+      total = 0;
+      nextIndex = 0;
+    },
+    total() {
+      return total;
+    },
+  };
+};
+
+const defaultTracker = createLogGrowthTracker();
+
+/**
+ * Count bytes written to the current session log.
+ *
+ * @param {number} bytes
+ * @returns {string|null} A warning to emit once, or null.
+ */
+export const recordLogBytes = bytes => defaultTracker.record(bytes);
+
+/**
+ * Start counting again - called when a new log file is set.
+ */
+export const resetLogGrowth = () => defaultTracker.reset();
+
+/**
+ * Bytes written to the current session log so far.
+ *
+ * @returns {number}
+ */
+export const getLoggedBytes = () => defaultTracker.total();
+
+export default { createLogGrowthTracker, recordLogBytes, resetLogGrowth, getLoggedBytes, LOG_GROWTH_THRESHOLDS };

package/src/option-suggestions.lib.mjs

@@ -194,6 +194,8 @@ const KNOWN_OPTION_NAMES = [
   'auto-resume-on-limit-reset',
   'auto-resume-on-errors',
   'auto-close-pull-request-on-fail',
+  'on-session-kill',
+  'session-kill-resume-attempts',
   'auto-pull-request-creation',
   'auto-commit-uncommitted-changes',
   'auto-restart-on-uncommitted-changes',

package/src/pull-request-changes.lib.mjs

@@ -36,6 +36,16 @@
  */
 
 import { ghWithRateLimitRetry } from './github-rate-limit.lib.mjs';
+import { quietProbe } from './quiet-probe.lib.mjs';
+
+/**
+ * Size at which a pull-request diff is worth complaining about (issue #2135).
+ *
+ * A diff this large is never the AI's source change: in the captured run it was
+ * CI logs and the solver's own development log committed into the branch. The
+ * warning is the early signal that was missing while the log grew to 286 MB.
+ */
+const LARGE_DIFF_WARNING_BYTES = 8 * 1024 * 1024;
 
 /**
  * The solver's own scaffolding files, recognised by the content it writes into
@@ -52,24 +62,76 @@ const PLACEHOLDER_CONTENT_PATTERNS = new Map([
   ['CLAUDE.md', [/^\+Issue to solve: \S+/m, /^\+Your prepared branch: \S+/m]],
 ]);
 
-/** Split a unified diff into one section per file. */
-const splitDiffByFile = diff => {
-  const sections = [];
-  for (const line of diff.split('\n')) {
+/**
+ * Measure a unified diff in a single pass.
+ *
+ * Issue #2135: the previous implementation split the whole diff into an array
+ * of lines, concatenated every line back into a per-file `body` string, and
+ * then counted additions with `body.match(/^\+[^+]/gm)` - a regex whose result
+ * is an array holding one string per added line. For the 60 MB pull-request
+ * diff captured in that run (the AI had committed CI logs and the solver's own
+ * development log into the branch) those three copies of the diff, plus a
+ * multi-million-entry match array, were a large part of the heap that ended the
+ * session with `FATAL ERROR: Reached heap limit`.
+ *
+ * This pass keeps no copy of the diff: it walks the string by line offsets,
+ * counts as it goes, and retains section text only for the two paths that can
+ * possibly be the solver's placeholder.
+ *
+ * The counting rules are unchanged: a line is an addition when it starts with
+ * `+` followed by a character other than `+` (so the `+++ b/path` header is not
+ * counted), and a deletion when it starts with `-` followed by a character
+ * other than `-`. Lines before the first `diff --git` header belong to no file
+ * and are ignored, exactly as they were when sections were built by splitting.
+ *
+ * @param {string} diff - unified diff text, possibly empty.
+ * @returns {{filesChanged: number, additions: number, deletions: number, placeholderSections: number}}
+ */
+const measureDiff = diff => {
+  let filesChanged = 0;
+  let additions = 0;
+  let deletions = 0;
+  let placeholderSections = 0;
+  let section = null;
+
+  const closeSection = () => {
+    if (!section) return;
+    const isPlaceholder = Boolean(section.patterns) && section.patterns.every(pattern => pattern.test(section.body));
+    if (isPlaceholder) placeholderSections += 1;
+    else {
+      filesChanged += 1;
+      additions += section.additions;
+      deletions += section.deletions;
+    }
+    section = null;
+  };
+
+  for (let start = 0; start < diff.length; ) {
+    let end = diff.indexOf('\n', start);
+    if (end === -1) end = diff.length;
+    const line = diff.slice(start, end);
+    start = end + 1;
+
     if (line.startsWith('diff --git ')) {
+      closeSection();
       const match = /^diff --git a\/(.+) b\/(.+)$/.exec(line);
-      sections.push({ path: match ? match[2] : '', body: '' });
+      const path = match ? match[2] : '';
+      const patterns = PLACEHOLDER_CONTENT_PATTERNS.get(path) || null;
+      section = { patterns, body: '', additions: 0, deletions: 0 };
       continue;
     }
-    if (sections.length > 0) sections[sections.length - 1].body += `${line}\n`;
+    if (!section) continue;
+    // Only a placeholder candidate needs its text kept; every other file is
+    // reduced to two counters as it streams past.
+    if (section.patterns) section.body += `${line}\n`;
+    if (line.length > 1) {
+      if (line[0] === '+' && line[1] !== '+') section.additions += 1;
+      else if (line[0] === '-' && line[1] !== '-') section.deletions += 1;
+    }
   }
-  return sections;
-};
+  closeSection();
 
-/** True when this file section is nothing but the solver's own placeholder. */
-const isPlaceholderSection = section => {
-  const patterns = PLACEHOLDER_CONTENT_PATTERNS.get(section.path);
-  return Boolean(patterns) && patterns.every(pattern => pattern.test(section.body));
+  return { filesChanged, additions, deletions, placeholderSections };
 };
 
 /**
@@ -84,17 +146,25 @@ const isPlaceholderSection = section => {
  * @param {string} params.repo
  * @param {number} params.prNumber
  * @param {Function} params.$ command-stream tagged-template executor
- * @returns {Promise<{hasChanges: boolean, filesChanged: number, additions: number, deletions: number, placeholderOnly: boolean, measured: boolean}>}
+ * @param {Function} [params.log] - optional logger for the size diagnostic
+ * @returns {Promise<{hasChanges: boolean, filesChanged: number, additions: number, deletions: number, placeholderOnly: boolean, measured: boolean, diffBytes: number}>}
  *   The counts cover the AI's own work: the solver's placeholder file is
  *   excluded and reported through `placeholderOnly` instead. `measured` is
  *   false when the diff could not be fetched, in which case callers must not
- *   treat the pull request as empty.
+ *   treat the pull request as empty. `diffBytes` is the size of the diff that
+ *   was measured, so a caller can see a runaway pull request growing.
  */
-export const getPullRequestChangeStats = async ({ owner, repo, prNumber, $ }) => {
+export const getPullRequestChangeStats = async ({ owner, repo, prNumber, $, log = null }) => {
   let diffOutput = '';
   let measured = false;
   try {
-    const result = await ghWithRateLimitRetry(() => $`gh pr diff ${prNumber} --repo ${owner}/${repo}`, { label: `pr diff ${owner}/${repo}#${prNumber}` });
+    // Issue #2135: `mirror: false`. This diff is read to answer one yes/no
+    // question, and every caller reports the answer in words - but it was being
+    // echoed into the log that the solver then attaches to the pull request and
+    // (with --development-log) commits into the branch, which put the previous
+    // copy of the diff inside the next one. Seven such copies grew one session
+    // log to 286 MB and ended it with a V8 out-of-memory abort.
+    const result = await ghWithRateLimitRetry(() => quietProbe($)`gh pr diff ${prNumber} --repo ${owner}/${repo}`, { label: `pr diff ${owner}/${repo}#${prNumber}` });
     if (result.code === 0) {
       diffOutput = result.stdout.toString();
       measured = true;
@@ -103,22 +173,22 @@ export const getPullRequestChangeStats = async ({ owner, repo, prNumber, $ }) =>
     // Leave measured false: an unreachable API must not read as "no changes".
   }
 
-  const sections = splitDiffByFile(diffOutput);
-  const placeholderSections = sections.filter(isPlaceholderSection);
-  const realSections = sections.filter(section => !isPlaceholderSection(section));
+  const { filesChanged, additions, deletions, placeholderSections } = measureDiff(diffOutput);
+  const diffBytes = diffOutput.length;
 
-  const countMatches = (pattern, text) => (text.match(pattern) || []).length;
-  const filesChanged = realSections.length;
-  const additions = realSections.reduce((total, section) => total + countMatches(/^\+[^+]/gm, section.body), 0);
-  const deletions = realSections.reduce((total, section) => total + countMatches(/^-[^-]/gm, section.body), 0);
+  if (measured && diffBytes >= LARGE_DIFF_WARNING_BYTES && typeof log === 'function') {
+    // Always megabytes: the threshold itself is 8 MB, so no unit choice is needed.
+    await log(`⚠️  Pull request #${prNumber} diff is ${(diffBytes / (1024 * 1024)).toFixed(1)} MB - measuring it is slow and memory-hungry; check whether logs or build output were committed to the branch`, { level: 'warning' });
+  }
 
   return {
     hasChanges: filesChanged > 0,
     filesChanged,
     additions,
     deletions,
-    placeholderOnly: filesChanged === 0 && placeholderSections.length > 0,
+    placeholderOnly: filesChanged === 0 && placeholderSections > 0,
     measured,
+    diffBytes,
   };
 };
 

package/src/review.mjs

@@ -48,6 +48,7 @@ const fs = (await use('fs')).promises;
 
 // Import shared functions from lib.mjs to follow DRY principle
 import { parseCliArgumentsWithLino } from './cli-arguments.lib.mjs';
+import { QUIET_PROBE } from './quiet-probe.lib.mjs';
 import { reportError } from './sentry.lib.mjs';
 import * as memoryCheck from './memory-check.mjs';
 
@@ -222,7 +223,11 @@ let limitReached = false;
 try {
   // Get PR details first
   await log('📊 Getting pull request details...');
-  const prDetailsResult = await $`gh pr view ${prUrl} --json title,body,headRefName,baseRefName,author,number,state,files`;
+  // Issue #2135: `mirror: false`. The answer is a JSON object holding the whole
+  // description and every changed file - it is written to a file for the AI
+  // tool and summarised in words below, so echoing it into the log only grew
+  // the log that is later attached to the pull request.
+  const prDetailsResult = await $(QUIET_PROBE)`gh pr view ${prUrl} --json title,body,headRefName,baseRefName,author,number,state,files`;
 
   if (prDetailsResult.code !== 0) {
     await log('Error: Failed to get PR details', { level: 'error' });
@@ -271,7 +276,11 @@ try {
 
   // Get the diff for the PR
   await log('📝 Getting PR diff...');
-  const diffResult = await $`gh pr diff ${prUrl}`;
+  // Issue #2135: `mirror: false`. The diff is saved to a file (below) and its
+  // size is reported in words; mirroring it copied a whole pull-request diff
+  // into the session log, which is exactly the growth that ended one run with
+  // an out-of-memory abort.
+  const diffResult = await $(QUIET_PROBE)`gh pr diff ${prUrl}`;
 
   if (diffResult.code !== 0) {
     await log('Error: Failed to get PR diff', { level: 'error' });
@@ -426,7 +435,7 @@ Review this pull request thoroughly.`;
 
       try {
         // Get reviews for the PR
-        const reviewsResult = await $`gh api repos/${owner}/${repo}/pulls/${prNumber}/reviews --paginate --jq '.[] | select(.user.login == "'$(gh api user --jq .login)'") | {state, submitted_at}'`;
+        const reviewsResult = await $(QUIET_PROBE)`gh api repos/${owner}/${repo}/pulls/${prNumber}/reviews --paginate --jq '.[] | select(.user.login == "'$(gh api user --jq .login)'") | {state, submitted_at}'`;
 
         if (reviewsResult.code === 0 && reviewsResult.stdout.toString().trim()) {
           await log(`✅ Review has been submitted to PR #${prNumber}`);