@link-assistant/hive-mind 2.11.8 → 2.11.10

package/src/hive.mjs

@@ -35,6 +35,7 @@ if (earlyArgs.includes('--help') || earlyArgs.includes('-h')) {
   }
 }
 export { createYargsConfig } from './hive.config.lib.mjs';
+import { attachChildExitHandlers } from './child-exit.lib.mjs';
 import { isDirectExecution, withTimeout } from './hive.bootstrap.lib.mjs';
 import { createShutdownManager } from './hive.shutdown.lib.mjs';
 const isRunningDirectly = isDirectExecution(process.argv[1], import.meta.url);
@@ -862,27 +863,20 @@ if (isRunningDirectly) {
                 }
               });
 
-              // Handle process completion
-              child.on('close', code => {
-                activeSolveChildren.delete(child); // Issue #1823: no longer in-flight
-                exitCode = code || 0;
-                resolve();
-              });
-
-              // Handle process errors
-              child.on('error', error => {
-                activeSolveChildren.delete(child); // Issue #1823: no longer in-flight
-                exitCode = 1;
-                log(`   [${solveCommand} worker-${workerId} ERROR] Process error: ${error.message}`, {
-                  level: 'error',
-                }).catch(logError => {
-                  reportError(logError, {
-                    context: 'worker_process_error_log',
-                    workerId,
-                    operation: 'log_process_error',
-                  });
-                });
-                resolve();
+              // Handle process completion and spawn failure. Issue #2135: a signalled
+              // child reports `code === null`, which `code || 0` read as success.
+              attachChildExitHandlers({
+                child,
+                command: solveCommand,
+                label: `   [${solveCommand} worker-${workerId}]`,
+                errorLabel: `   [${solveCommand} worker-${workerId} ERROR]`,
+                log,
+                onLogError: (logError, operation) => reportError(logError, { context: 'worker_child_exit_log', workerId, operation }),
+                onExit: result => {
+                  activeSolveChildren.delete(child); // Issue #1823: no longer in-flight
+                  exitCode = result.exitCode;
+                  resolve();
+                },
               });
             });
 

package/src/isolation-runner.lib.mjs

@@ -15,6 +15,7 @@ import { ensureUseM } from './use-m-bootstrap.lib.mjs';
 
 import crypto from 'crypto';
 import { spawn } from 'node:child_process';
+import { describeChildExit } from './child-exit.lib.mjs';
 import { lookup as lookupHost } from 'node:dns/promises';
 import fs from 'node:fs';
 import os from 'node:os';
@@ -351,7 +352,9 @@ async function runStartCommand(binPath, startCommandArgs) {
         error: error.message,
       });
     });
-    child.on('close', code => {
+    // Issue #2135: keep `signal` - the captured session's child was killed by
+    // one, and `code` alone was null.
+    child.on('close', (code, signal) => {
       const output = (stdout + (stderr ? `\n${stderr}` : '')).trim();
       if (code === 0) {
         resolve({ success: true, output, error: null });
@@ -359,7 +362,7 @@ async function runStartCommand(binPath, startCommandArgs) {
         resolve({
           success: false,
           output,
-          error: stderr.trim() || `start-command exited with code ${code}`,
+          error: stderr.trim() || describeChildExit({ command: 'start-command', code, signal }),
         });
       }
     });

package/src/lib.mjs

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { ensureUseM } from './use-m-bootstrap.lib.mjs';
 import { createCredentialStreamSanitizer, maskToken, sanitizeCredentialText } from './credential-sanitization-core.lib.mjs';
+import { recordLogBytes, resetLogGrowth } from './log-growth.lib.mjs'; // issue #2135: notice a session log that is running away
 
 export { maskToken };
 
@@ -51,6 +52,23 @@ export let logFile = null;
  */
 export const setLogFile = path => {
   logFile = path;
+  resetLogGrowth(); // issue #2135: a new log starts its growth accounting over
+};
+
+/**
+ * Issue #2135: count what is written to the session log and say so once the
+ * total stops being reasonable. Called from every append path below.
+ *
+ * The warning is emitted with console.warn rather than log(): these call sites
+ * are inside the append paths themselves, and console output is captured into
+ * the same log by the stdio interceptor, so the evidence lands in the log that
+ * is misbehaving.
+ *
+ * @param {string} appendedText - exactly what was appended, including newline.
+ */
+const noteLogBytesWritten = appendedText => {
+  const warning = recordLogBytes(Buffer.byteLength(appendedText));
+  if (warning) console.warn(warning);
 };
 
 /**
@@ -100,6 +118,7 @@ export const log = async (message, options = {}) => {
     try {
       await fs.appendFile(logFile, logMessage + '\n', { mode: 0o600 });
       await fs.chmod(logFile, 0o600);
+      noteLogBytesWritten(logMessage + '\n');
     } catch (error) {
       // Silent fail for file append errors to avoid infinite loop
       // but report to Sentry in verbose mode
@@ -349,6 +368,7 @@ export const setupStdioLogInterceptor = () => {
         const logMessage = `[${new Date().toISOString()}] [STDOUT] ${text.replace(/\n$/, '')}`;
         fs.appendFile(logFile, logMessage + '\n', { mode: 0o600 })
           .then(() => fs.chmod(logFile, 0o600))
+          .then(() => noteLogBytesWritten(logMessage + '\n')) // issue #2135
           .catch(() => {
             // Silent fail to avoid infinite loops
           });
@@ -382,6 +402,7 @@ export const setupStdioLogInterceptor = () => {
         const logMessage = `[${new Date().toISOString()}] [STDERR] ${text.replace(/\n$/, '')}`;
         fs.appendFile(logFile, logMessage + '\n', { mode: 0o600 })
           .then(() => fs.chmod(logFile, 0o600))
+          .then(() => noteLogBytesWritten(logMessage + '\n')) // issue #2135
           .catch(() => {
             // Silent fail to avoid infinite loops
           });

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/opencode.lib.mjs

@@ -343,9 +343,19 @@ export const executeOpenCodeCommand = async params => {
       const stdoutScanner = createJsonStreamScanner();
       const stderrScanner = createJsonStreamScanner();
 
-      const handleOpenCodeRecords = events => {
+      // Issue #2136: count the JSON records that arrive on stderr. OpenCode has
+      // no terminal-event completion gate (success is decided by the exit code),
+      // so unlike codex and qwen these records cannot fail a healthy run — but
+      // they do feed `lastTextContent` and token usage, and a CLI that echoes a
+      // nested agent's stream would silently skew both. Issue #1263 added stderr
+      // parsing deliberately (some OpenCode-derived CLIs emit their records
+      // there), so the behaviour is kept and only made visible.
+      let stderrJsonRecordCount = 0;
+
+      const handleOpenCodeRecords = (events, { source = 'stdout' } = {}) => {
         for (const event of events) {
           if (event.type !== 'json') continue;
+          if (source === 'stderr') stderrJsonRecordCount++;
           const data = sanitizeObjectStrings(event.value);
           // Issue #1968: a bare `null`/primitive record must not abort the
           // rest of the chunk (data.type access would throw on null).
@@ -399,7 +409,7 @@ export const executeOpenCodeCommand = async params => {
             allOutput += errorOutput;
 
             // Issue #1263: Also parse stderr for text content
-            handleOpenCodeRecords(stderrScanner.write(errorOutput));
+            handleOpenCodeRecords(stderrScanner.write(errorOutput), { source: 'stderr' });
           }
         } else if (chunk.type === 'exit') {
           exitCode = chunk.code;
@@ -408,7 +418,11 @@ export const executeOpenCodeCommand = async params => {
 
       // Release any record that was still being assembled when the stream ended.
       handleOpenCodeRecords(stdoutScanner.flush());
-      handleOpenCodeRecords(stderrScanner.flush());
+      handleOpenCodeRecords(stderrScanner.flush(), { source: 'stderr' });
+
+      if (stderrJsonRecordCount > 0) {
+        await log(`🪞 JSON records parsed from OpenCode stderr: ${stderrJsonRecordCount} (issue #2136: stderr is not a protocol stream — check these before trusting usage/summary)`, { verbose: true });
+      }
 
       // Clean up the opencode.json config file to avoid polluting the repository
       try {

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/qwen.lib.mjs

@@ -143,6 +143,10 @@ const extractTextFragments = value => {
 
 const createQwenParserState = state => ({
   buffer: state?.buffer || '',
+  // Issue #2136: stderr is framed independently of stdout — mixing the two into
+  // one buffer would splice half of a stdout record onto a stderr line.
+  telemetryBuffer: state?.telemetryBuffer || '',
+  telemetryEventCounts: { ...(state?.telemetryEventCounts || {}) },
   plainText: state?.plainText || '',
   parsedEvents: Array.isArray(state?.parsedEvents) ? [...state.parsedEvents] : [],
   eventCounts: { ...(state?.eventCounts || {}) },
@@ -324,24 +328,45 @@ const addQwenEventToState = (state, rawEvent) => {
   applyQwenUsageToState(state, event);
 };
 
-export const parseQwenStreamJsonOutput = (output, state = {}) => {
+// Issue #2136: qwen-code writes its stream-json protocol to stdout; stderr is
+// human/diagnostic text. Feeding stderr through the protocol parser made every
+// JSON object a CLI happened to print there — including output a task's own
+// commands echoed back — a genuine qwen event, which could invent an `errors`
+// entry (an instant run failure), hijack the session id, add phantom token usage
+// or satisfy the #1990 terminal-event gate. Codex was bitten by exactly this
+// (see docs/case-studies/issue-2136), so qwen now marks non-stdout records as
+// telemetry: they are counted for diagnostics and otherwise ignored. Plain-text
+// stderr signals are unaffected — auth/usage-limit/retry classification still
+// reads the raw combined output.
+export const parseQwenStreamJsonOutput = (output, state = {}, { source = 'stdout' } = {}) => {
   const nextState = createQwenParserState(state);
   const text = output?.toString?.() ?? String(output || '');
   nextState.plainText += text;
 
+  const isProtocolStream = source === 'stdout';
+
   // Issue #2119: frame the stream by balanced JSON values instead of by lines.
   // `formal-ai with qwen` emits pretty-printed, multi-line records, so every
   // line failed to parse and every event - including the token usage - was
   // dropped. Scanning for balanced values also covers records concatenated
   // without a separator and records split across two process chunks.
-  const { records, rest } = takeJsonRecords(`${nextState.buffer}${text}`);
-  nextState.buffer = rest;
+  const pendingBuffer = isProtocolStream ? nextState.buffer : nextState.telemetryBuffer;
+  const { records, rest } = takeJsonRecords(`${pendingBuffer}${text}`);
+  if (isProtocolStream) {
+    nextState.buffer = rest;
+  } else {
+    nextState.telemetryBuffer = rest;
+  }
 
   for (const record of records) {
-    if (Array.isArray(record)) {
-      for (const item of record) addQwenEventToState(nextState, item);
-    } else {
-      addQwenEventToState(nextState, record);
+    const items = Array.isArray(record) ? record : [record];
+    for (const item of items) {
+      if (isProtocolStream) {
+        addQwenEventToState(nextState, item);
+        continue;
+      }
+      const eventType = item?.type || item?.event || 'unknown';
+      nextState.telemetryEventCounts[eventType] = (nextState.telemetryEventCounts[eventType] || 0) + 1;
     }
   }
 
@@ -551,7 +576,8 @@ export const executeQwenCommand = async params => {
           if (errorOutput) {
             await log(errorOutput, { stream: 'stderr' });
             allOutput += errorOutput;
-            qwenState = parseQwenStreamJsonOutput(errorOutput, qwenState);
+            // Issue #2136: stderr is diagnostics, not the qwen protocol stream.
+            qwenState = parseQwenStreamJsonOutput(errorOutput, qwenState, { source: 'stderr' });
           }
         } else if (chunk.type === 'exit') {
           exitCode = chunk.code;
@@ -562,6 +588,14 @@ export const executeQwenCommand = async params => {
         qwenState = parseQwenStreamJsonOutput(`${qwenState.buffer}\n`, { ...qwenState, buffer: '' });
       }
 
+      // Issue #2136: make the ignored non-protocol JSON visible, so a future
+      // investigation can tell "qwen emitted no result event" apart from "the
+      // records in the log came from stderr and were correctly ignored".
+      const qwenTelemetryTypes = Object.entries(qwenState.telemetryEventCounts || {});
+      if (qwenTelemetryTypes.length > 0) {
+        await log(`🪞 JSON records on qwen stderr (ignored, not protocol events): ${qwenTelemetryTypes.map(([type, count]) => `${type}=${count}`).join(', ')}`, { verbose: true });
+      }
+
       const sessionId = qwenState.sessionId || null;
       const resultSummary = qwenState.lastTextContent || null;
       const errorMessage = qwenState.errors

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}`);

package/src/session-kill-recovery.lib.mjs

@@ -23,6 +23,7 @@
  */
 
 import { spawn } from 'child_process';
+import { describeChildExit } from './child-exit.lib.mjs';
 import { KILL_CAUSE_DISK_FULL, KILL_CAUSE_FORCED_KILL, KILL_CAUSE_OUT_OF_MEMORY } from './session-kill-diagnostics.lib.mjs';
 import { ON_SESSION_KILL_RESUME } from './session-kill-policy.lib.mjs';
 
@@ -137,7 +138,10 @@ export function spawnCapture(command, args, options = {}) {
       stderr += data.toString();
     });
     child.on('error', error => resolve({ code: 1, stdout, stderr: stderr || error.message }));
-    child.on('close', code => resolve({ code, stdout, stderr }));
+    // Issue #2135: keep the signal. `close` reports `code === null` for a
+    // signalled child, and interpolating that null is how "exited with code
+    // null" reached a user notification with no cause attached.
+    child.on('close', (code, signal) => resolve({ code, signal, stdout, stderr }));
   });
 }
 
@@ -181,7 +185,7 @@ export async function postKillRecoveryNotice({ pullRequestUrl, body, runCommand
       if (verbose) console.log(`[VERBOSE] Posted killed-session notice to ${pullRequestUrl}${url ? ` (${url})` : ''}`);
       return { posted: true, url, error: null };
     }
-    const error = String(result?.stderr || result?.stdout || `gh pr comment exited with code ${result?.code}`).trim();
+    const error = String(result?.stderr || result?.stdout || describeChildExit({ command: 'gh pr comment', code: result?.code, signal: result?.signal })).trim();
     if (verbose) console.log(`[VERBOSE] Failed to post killed-session notice: ${error}`);
     return { posted: false, url: null, error };
   } catch (error) {

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

@@ -537,7 +537,10 @@ export const processAutoContinueForIssue = async (argv, isIssueUrl, urlNumber, o
 
           // List all branches in the fork that match the pattern issue-{issueNumber}-* (supports both 8-char and 12-char formats)
           const branchPattern = getIssueBranchPrefix(issueNumber);
-          const branchListResult = await $`gh api --paginate repos/${forkRepo}/branches --jq '.[].name'`;
+          // Issue #2135: `mirror: false`. The list grows with the repository -
+          // a repository worked on by the solver accumulates one branch per
+          // issue - and only the matching ones are reported below.
+          const branchListResult = await $(QUIET_PROBE)`gh api --paginate repos/${forkRepo}/branches --jq '.[].name'`;
 
           if (branchListResult.code === 0) {
             const allBranches = branchListResult.stdout
@@ -575,7 +578,8 @@ export const processAutoContinueForIssue = async (argv, isIssueUrl, urlNumber, o
 
       // List all branches in the main repo that match the pattern issue-{issueNumber}-* (supports both 8-char and 12-char formats)
       const branchPattern = getIssueBranchPrefix(issueNumber);
-      const branchListResult = await $`gh api --paginate repos/${owner}/${repo}/branches --jq '.[].name'`;
+      // Issue #2135: `mirror: false` - see the fork branch listing above.
+      const branchListResult = await $(QUIET_PROBE)`gh api --paginate repos/${owner}/${repo}/branches --jq '.[].name'`;
 
       if (branchListResult.code === 0) {
         const allBranches = branchListResult.stdout

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

@@ -293,7 +293,7 @@ export const watchUntilMergeable = async params => {
       // reproduction run posted "✅ Ready to merge - No pending changes" for a
       // pull request whose net diff was empty, so merging it would have closed
       // the issue without implementing anything.
-      const changeStats = await getPullRequestChangeStats({ owner, repo, prNumber, $ });
+      const changeStats = await getPullRequestChangeStats({ owner, repo, prNumber, $, log });
       const isEmptyPullRequest = changeStats.measured && !changeStats.hasChanges;
       const emptyPullRequestBlocker = buildEmptyPullRequestBlocker(changeStats);
       if (isEmptyPullRequest) {