@link-assistant/hive-mind 2.11.8 → 2.11.9

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # @link-assistant/hive-mind
 
+## 2.11.9
+
+### Patch Changes
+
+- 202bef0: Stop the session log from swallowing the pull request diff (issue #2135).
+
+  A session ended as `Work session failed (exit code: 1)` after its log reached
+  286 MB and the solve process died on the V8 heap limit.
+  `getPullRequestChangeStats` ran `gh pr diff` with command-stream's default
+  `mirror: true`, so the whole diff was echoed to stdout, copied into the session
+  log, committed to the branch by `--development-log`, and included again in the
+  next run's diff — each round larger than the last.
+
+  - `gh pr diff` is now read quietly and measured in a single streaming pass, with
+    a warning past 8 MB; the same quiet-probe treatment is applied to every other
+    unbounded-output probe, pinned by a source-scanning regression test.
+  - `src/contributing-guidelines.lib.mjs` no longer calls `.raw()` on a wrapped
+    `gh` promise, a `TypeError` that silently disabled guideline detection.
+  - New `src/child-exit.lib.mjs`: a child killed by a signal is reported as such
+    instead of `exited with code null`, and `hive` no longer records an
+    out-of-memory worker as a success.
+  - New `src/log-growth.lib.mjs`: the session log warns at 64 MB / 256 MB / 1 GB,
+    naming the usual cause, so a runaway log is visible before it is fatal.
+  - A failed development-log publication now discards the copies it wrote instead
+    of leaving them untracked, where they were read as the AI's uncommitted work
+    and triggered the restarts that multiplied the growth.
+  - `docs/case-studies/issue-2135` records the timeline, evidence and analysis.
+
 ## 2.11.8
 
 ### Patch Changes

package/package.json

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

package/src/bidirectional-interactive.lib.mjs

@@ -243,7 +243,10 @@ export const createBidirectionalHandler = options => {
    */
   const fetchCommentsFromEndpoint = async (apiPath, source) => {
     try {
-      const result = await $`gh api ${apiPath} --paginate --slurp`;
+      // Issue #2135: `mirror: false`. This is every comment body on the issue
+      // or pull request, re-read on a poll interval; mirroring it copied the
+      // whole conversation into the log once per poll.
+      const result = await quietProbe($)`gh api ${apiPath} --paginate --slurp`;
       const parsed = JSON.parse(result.stdout?.toString() || '[]');
       const comments = Array.isArray(parsed) && parsed.every(Array.isArray) ? parsed.flat() : parsed;
       return comments.map(comment => ({
@@ -476,7 +479,8 @@ export const createBidirectionalHandler = options => {
     if (!number || !owner || !repo) return null;
     try {
       const endpoint = kind === 'pr' ? `repos/${owner}/${repo}/pulls/${number}` : `repos/${owner}/${repo}/issues/${number}`;
-      const result = await $`gh api ${endpoint} --jq '{title, body}'`;
+      // Issue #2135: `mirror: false` - the snapshot is compared, not shown.
+      const result = await quietProbe($)`gh api ${endpoint} --jq '{title, body}'`;
       if (!result || result.code !== 0) return null;
       const parsed = JSON.parse(result.stdout.toString() || '{}');
       return { title: parsed.title || '', body: parsed.body || '' };

package/src/child-exit.lib.mjs

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+
+/**
+ * Say why a child process ended (issue #2135).
+ *
+ * The session captured for that issue ended with the solve child aborting on a
+ * V8 heap limit:
+ *
+ *   FATAL ERROR: Reached heap limit Allocation failed - JavaScript heap out of memory
+ *
+ * `node` answers that by calling `abort()`, so the child is terminated by a
+ * signal and `child.on('close')` reports `code === null`. Every spawner in this
+ * repository interpolated that `code` straight into its message and produced
+ *
+ *   ❌ Error: solve exited with code null
+ *
+ * which says nothing about memory, and the wrapper's own exit code 1 was all
+ * that reached the Telegram notification ("Work session failed (exit code:
+ * 1)"). The signal was known at that moment and simply thrown away.
+ *
+ * @module child-exit
+ */
+
+/**
+ * What a signal says about how the child died.
+ *
+ * SIGABRT is the one that matters here: `node` aborts on a fatal V8 error, and
+ * "reached heap limit" is by far the most common of those in this codebase.
+ * SIGKILL is the other memory ending - the kernel's OOM killer, or a container
+ * runtime enforcing a memory limit, neither of which lets the process print
+ * anything at all.
+ */
+const SIGNAL_EXPLANATIONS = new Map([
+  ['SIGABRT', 'the process aborted - for Node.js this is usually a fatal V8 error such as "Reached heap limit Allocation failed - JavaScript heap out of memory"; look for "FATAL ERROR" above'],
+  ['SIGKILL', 'the process was killed outright - usually the kernel out-of-memory killer or a container memory limit; nothing it could print survives this'],
+  ['SIGTERM', 'the process was asked to terminate - usually a timeout, a container stop, or another process shutting it down'],
+  ['SIGINT', 'the process was interrupted (Ctrl+C)'],
+  ['SIGSEGV', 'the process crashed with a segmentation fault'],
+]);
+
+/**
+ * Describe how a spawned child ended, in a sentence a log reader can act on.
+ *
+ * @param {object} params
+ * @param {string} params.command - what was spawned, as the reader knows it (e.g. `solve`).
+ * @param {number|null} [params.code] - the exit code from `close`/`exit`, null when signalled.
+ * @param {string|null} [params.signal] - the signal name from `close`/`exit`, when there is one.
+ * @returns {string} A description ending without punctuation, ready to be used
+ *   as an `Error` message or logged as-is.
+ */
+export const describeChildExit = ({ command, code = null, signal = null }) => {
+  if (signal) {
+    const explanation = SIGNAL_EXPLANATIONS.get(signal);
+    return explanation ? `${command} was terminated by signal ${signal}: ${explanation}` : `${command} was terminated by signal ${signal}`;
+  }
+  if (code === null || code === undefined) {
+    // No code and no signal: rare, but "code null" on its own is exactly the
+    // uninformative message this module exists to replace.
+    return `${command} exited without a status code, so it did not finish normally (no signal was reported either)`;
+  }
+  return `${command} exited with code ${code}`;
+};
+
+/**
+ * True when the ending looks like the child ran out of memory.
+ *
+ * Callers use this to add the one hint that would have saved the captured
+ * session: the child died of memory pressure, not of a failed check.
+ *
+ * @param {object} params
+ * @param {number|null} [params.code]
+ * @param {string|null} [params.signal]
+ * @returns {boolean}
+ */
+export const isLikelyOutOfMemoryExit = ({ code = null, signal = null }) => signal === 'SIGABRT' || signal === 'SIGKILL' || (signal === null && code === 134);
+
+/**
+ * Wire `close`/`error` handlers that never lose a signal.
+ *
+ * The exit code handed to `onExit` is 1 for a signalled child: `code || 0`
+ * turned the `null` of a signalled exit into a success, so a worker killed by
+ * the OOM killer looked like a worker that finished its issue.
+ *
+ * @param {object} params
+ * @param {import('node:child_process').ChildProcess} params.child
+ * @param {string} params.command - what was spawned, as the log reader knows it.
+ * @param {string} params.label - prefix for the exit line (e.g. `   [solve worker-1]`).
+ * @param {string} [params.errorLabel] - prefix for the spawn-failure line; defaults to `label`.
+ * @param {Function} params.log - async logger, `(message, options) => Promise`.
+ * @param {Function} [params.onLogError] - called as `(error, operation)` when logging itself fails.
+ * @param {Function} params.onExit - called once with `{ exitCode, code, signal, error }`.
+ */
+export const attachChildExitHandlers = ({ child, command, label, errorLabel = label, log, onLogError = () => {}, onExit }) => {
+  child.on('close', (code, signal) => {
+    if (signal) {
+      log(`${label} ${describeChildExit({ command, code, signal })}`, { level: 'error' }).catch(logError => onLogError(logError, 'log_child_signal_exit'));
+    }
+    onExit({ exitCode: signal ? 1 : code || 0, code, signal, error: null });
+  });
+
+  child.on('error', error => {
+    log(`${errorLabel} Process error: ${error.message}`, { level: 'error' }).catch(logError => onLogError(logError, 'log_child_process_error'));
+    onExit({ exitCode: 1, code: null, signal: null, error });
+  });
+};
+
+export default { describeChildExit, isLikelyOutOfMemoryExit, attachChildExitHandlers };

package/src/contributing-guidelines.lib.mjs

@@ -13,6 +13,7 @@ if (typeof globalThis.use === 'undefined') {
 const { $: __rawDollar$ } = await use('command-stream');
 const { wrapDollarWithGhRetry } = await import('./github-rate-limit.lib.mjs');
 const $ = wrapDollarWithGhRetry(__rawDollar$);
+const { QUIET_PROBE } = await import('./quiet-probe.lib.mjs'); // issue #2135: keep large read-only probe payloads out of the attached log
 /**
  * Common paths where contributing guidelines might be found
  */
@@ -41,15 +42,25 @@ export async function detectContributingGuidelines(owner, repo) {
   // Try to find CONTRIBUTING file in the repo
   for (const path of CONTRIBUTING_PATHS) {
     try {
-      const checkResult = await $`gh api repos/${owner}/${repo}/contents/${path} 2>/dev/null`.raw().trim();
-      if (checkResult.exitCode === 0 && checkResult.text) {
+      // Issue #2135: `mirror: false` - the answer is the file's whole content,
+      // base64-encoded, and it is decoded into `result.content` below rather
+      // than read from the log.
+      //
+      // `.raw()` used to be called on this result: `$` is wrapped by
+      // `wrapDollarWithGhRetry`, which returns a plain promise for `gh`
+      // commands, so `.raw()` threw a TypeError that the `catch` below
+      // swallowed - every repository looked as if it had no contributing
+      // guidelines. The command-stream result fields are read directly instead.
+      const checkResult = await $(QUIET_PROBE)`gh api repos/${owner}/${repo}/contents/${path} 2>/dev/null`;
+      const checkText = checkResult.stdout ? checkResult.stdout.toString().trim() : '';
+      if (checkResult.code === 0 && checkText) {
         result.found = true;
         result.path = path;
         result.url = `https://github.com/${owner}/${repo}/blob/main/${path}`;
 
         // Try to get the content from the response
         try {
-          const data = JSON.parse(checkResult.text);
+          const data = JSON.parse(checkText);
           if (data.content) {
             // Decode base64 content
             result.content = Buffer.from(data.content, 'base64').toString('utf-8');
@@ -68,9 +79,11 @@ export async function detectContributingGuidelines(owner, repo) {
   // Try to find docs URL in README
   if (!result.found) {
     try {
-      const readme = await $`gh api repos/${owner}/${repo}/readme 2>/dev/null`.raw().trim();
-      if (readme.exitCode === 0 && readme.text) {
-        const readmeData = JSON.parse(readme.text);
+      // Issue #2135: `mirror: false`, and the same `.raw()` fix as above.
+      const readme = await $(QUIET_PROBE)`gh api repos/${owner}/${repo}/readme 2>/dev/null`;
+      const readmeText = readme.stdout ? readme.stdout.toString().trim() : '';
+      if (readme.code === 0 && readmeText) {
+        const readmeData = JSON.parse(readmeText);
         const readmeContent = Buffer.from(readmeData.content, 'base64').toString('utf-8');
 
         // Look for contributing documentation URL

package/src/development-log.lib.mjs

@@ -290,6 +290,62 @@ const verifyDevelopmentLogDirectory = async directoryPath => {
 
 const getCommandOutput = result => (result?.stderr?.toString?.() || result?.stdout?.toString?.() || '').trim();
 
+/**
+ * Issue #2135: leave no untracked residue behind when publication fails.
+ *
+ * The artifacts are written into the user's workspace *before* they can be
+ * verified, staged and committed. When any of those steps fails the copies stay
+ * on disk, and every later `git status --porcelain` reports them:
+ *
+ *     ⚠️  Development log collection failed: Development-log publication rescan
+ *         found residual credential material.
+ *     ?? dev/log/issues/191/pulls/192/sessions/
+ *     📝 Found uncommitted changes
+ *     🔄 AUTO-RESTART: Restarting Claude to handle uncommitted changes...
+ *
+ * The restarted session is then told it MUST commit those changes - so hive-mind
+ * asks the AI to commit hive-mind's own session log into the user's branch, and
+ * the next `gh pr diff` carries it (docs/case-studies/issue-2135, RC6).
+ *
+ * The copies are exactly that - copies; the originals stay in the session log
+ * and the tool's own state directory, so discarding them loses nothing. Only
+ * this run's session directory is removed, and only while it is still
+ * uncommitted.
+ *
+ * @param {object} params
+ * @param {string} params.repositoryPath
+ * @param {string} params.sessionRelativeDirectory - this run's session directory
+ * @param {string} params.relativeDirectory - the development-log directory that may hold staged paths
+ * @param {Function} [params.$]
+ * @param {Function} [params.log]
+ * @returns {Promise<{discarded: boolean, reason?: string}>}
+ */
+export const discardUnpublishedDevelopmentLog = async ({ repositoryPath, sessionRelativeDirectory, relativeDirectory, $, log }) => {
+  if (!repositoryPath || !sessionRelativeDirectory) {
+    return { discarded: false, reason: 'nothing-to-discard' };
+  }
+
+  if ($ && relativeDirectory) {
+    // Unstage first: `git add -f` may already have run, and a staged-but-uncommitted
+    // path is just as good at triggering the restart loop as an untracked one.
+    try {
+      await $({ cwd: repositoryPath })`git reset -q -- ${relativeDirectory}`;
+    } catch (error) {
+      await log?.(`⚠️  Could not unstage development log artifacts: ${error.message}`, { level: 'warning' });
+    }
+  }
+
+  try {
+    await fs.rm(path.join(repositoryPath, sessionRelativeDirectory), { recursive: true, force: true });
+  } catch (error) {
+    await log?.(`⚠️  Could not remove unpublished development log artifacts in ${sessionRelativeDirectory}: ${error.message}`, { level: 'warning' });
+    return { discarded: false, reason: 'unremovable' };
+  }
+
+  await log?.(`🧹 Discarded unpublished development log artifacts in ${sessionRelativeDirectory} so they cannot be mistaken for the AI's uncommitted work (issue #2135)`);
+  return { discarded: true };
+};
+
 export const collectAndCommitDevelopmentLogArtifacts = async ({ enabled, repositoryPath, logFile, issueNumber, prNumber, tool, sessionId, branchName, rawCommand, logStartByte = 0, $, log }) => {
   if (!enabled) {
     return { skipped: 'disabled' };
@@ -303,8 +359,24 @@ export const collectAndCommitDevelopmentLogArtifacts = async ({ enabled, reposit
   // Issue #2048: verbose trace so the commit timing (relative to PR readiness signals) is diagnosable from logs.
   await log?.(`🔍 Development log finalize: issue #${issueNumber ?? '?'}, PR #${prNumber ?? 'pending'}, branch ${branchName ?? 'none'}, session ${sessionId ?? 'none'}, log slice from byte ${logStartByte}`, { verbose: true });
 
+  // Kept outside the try so the failure paths below (and the catch) can clean up
+  // the copies this run wrote into the workspace - see issue #2135, RC6.
+  let artifacts = null;
+  // Unstaging is only meaningful once staging has been attempted, and issue
+  // #2111 requires that no git command run before the residual-credential
+  // rescan - so the cleanup gets `$` only after `git add` was reached.
+  let stagingAttempted = false;
+  const discardArtifacts = async () =>
+    discardUnpublishedDevelopmentLog({
+      repositoryPath,
+      sessionRelativeDirectory: artifacts?.sessionRelativeDirectory,
+      relativeDirectory: artifacts?.relativeDirectory,
+      $: stagingAttempted ? $ : null,
+      log,
+    });
+
   try {
-    const artifacts = await writeDevelopmentLogArtifacts({
+    artifacts = await writeDevelopmentLogArtifacts({
       repositoryPath,
       logFile,
       issueNumber,
@@ -328,10 +400,12 @@ export const collectAndCommitDevelopmentLogArtifacts = async ({ enabled, reposit
     // call the publication helper.
     await verifyDevelopmentLogDirectory(path.join(repositoryPath, artifacts.relativeDirectory));
 
+    stagingAttempted = true;
     const addResult = await $({ cwd: repositoryPath })`git add -f -- ${artifacts.relativeDirectory}`;
     if (addResult.code !== 0) {
       await log?.(`⚠️  Could not stage development log: ${getCommandOutput(addResult)}`, { level: 'warning' });
-      return { ...artifacts, committed: false, pushed: false };
+      await discardArtifacts();
+      return { ...artifacts, committed: false, pushed: false, discarded: true };
     }
 
     const diffResult = await $({ cwd: repositoryPath })`git diff --cached --quiet -- ${artifacts.relativeDirectory}`;
@@ -341,14 +415,16 @@ export const collectAndCommitDevelopmentLogArtifacts = async ({ enabled, reposit
     }
     if (diffResult.code !== 1) {
       await log?.(`⚠️  Could not inspect staged development log changes: ${getCommandOutput(diffResult)}`, { level: 'warning' });
-      return { ...artifacts, committed: false, pushed: false };
+      await discardArtifacts();
+      return { ...artifacts, committed: false, pushed: false, discarded: true };
     }
 
     const commitMessage = prNumber ? `Add development log for issue #${issueNumber} PR #${prNumber}` : `Add development log for issue #${issueNumber}`;
     const commitResult = await $({ cwd: repositoryPath })`git commit -m ${commitMessage} -- ${artifacts.relativeDirectory}`;
     if (commitResult.code !== 0) {
       await log?.(`⚠️  Could not commit development log: ${getCommandOutput(commitResult)}`, { level: 'warning' });
-      return { ...artifacts, committed: false, pushed: false };
+      await discardArtifacts();
+      return { ...artifacts, committed: false, pushed: false, discarded: true };
     }
 
     await log?.('✅ Development log committed');
@@ -368,6 +444,7 @@ export const collectAndCommitDevelopmentLogArtifacts = async ({ enabled, reposit
     return { ...artifacts, committed: true, pushed: true };
   } catch (error) {
     await log?.(`⚠️  Development log collection failed: ${error.message}`, { level: 'warning' });
-    return { skipped: 'error', error };
+    const cleanup = await discardArtifacts();
+    return { skipped: 'error', error, discarded: cleanup.discarded };
   }
 };

package/src/fix.ci-cd-issue.lib.mjs

@@ -5,6 +5,7 @@
 
 import { spawn } from 'child_process';
 import { CI_CD_ISSUE_LABELS, CI_CD_ISSUE_TYPE, buildCiCdIssueBody, buildCiCdIssueTitle, dedupeRunsByWorkflow } from './fix.ci-cd.lib.mjs';
+import { describeChildExit } from './child-exit.lib.mjs';
 import { createTaskIssue } from './task.issue-creation.lib.mjs';
 
 function runCommand(command, args, options = {}) {
@@ -25,8 +26,8 @@ function runCommand(command, args, options = {}) {
     child.on('error', error => {
       resolve({ code: 1, stdout, stderr: stderr || error.message });
     });
-    child.on('close', code => {
-      resolve({ code, stdout, stderr });
+    child.on('close', (code, signal) => {
+      resolve({ code, stdout, stderr, signal });
     });
   });
 }
@@ -35,7 +36,8 @@ async function commandOutput(run, command, args) {
   const result = await run(command, args);
   if (result.code !== 0) {
     const output = `${result.stderr || ''}${result.stdout || ''}`.trim();
-    throw new Error(output || `${command} exited with code ${result.code}`);
+    // Issue #2135: `describeChildExit` names a signal instead of "code null".
+    throw new Error(output || describeChildExit({ command, code: result.code, signal: result.signal }));
   }
   return result.stdout.trim();
 }

package/src/fix.mjs

@@ -17,6 +17,7 @@ import path from 'path';
 import { spawn } from 'child_process';
 import { fileURLToPath } from 'url';
 import { buildSolveArgs, partitionFixArgs, summarizeRunFailures } from './fix.ci-cd.lib.mjs';
+import { describeChildExit } from './child-exit.lib.mjs';
 import { createCiCdIssue, prepareCiCdIssue } from './fix.ci-cd-issue.lib.mjs';
 import { setupStdioLogInterceptor } from './lib.mjs';
 
@@ -122,9 +123,11 @@ async function main() {
       env: process.env,
     });
     child.on('error', reject);
-    child.on('close', code => {
+    // Issue #2135: `signal` used to be dropped here, so a solve child that
+    // aborted on a V8 heap limit was reported as "solve exited with code null".
+    child.on('close', (code, signal) => {
       if (code === 0) resolve();
-      else reject(new Error(`solve exited with code ${code}`));
+      else reject(new Error(describeChildExit({ command: 'solve', code, signal })));
     });
   });
 }

package/src/github-entity-validation.lib.mjs

@@ -8,6 +8,7 @@ if (typeof globalThis.use === 'undefined') await ensureUseM();
 const { $ } = await use('command-stream');
 import { ghCmdRetry } from './lib.mjs';
 import { ghPrView, ghIssueView } from './github.lib.mjs';
+import { QUIET_PROBE } from './quiet-probe.lib.mjs';
 
 /**
  * Compute the Levenshtein edit distance between two strings.
@@ -116,7 +117,9 @@ export async function checkBaseBranchExists({ owner, repo, baseBranch, verbose =
 export async function buildMissingBaseBranchErrorMessage({ owner, repo, baseBranch, verbose = false }) {
   let suggestion = '';
   try {
-    const listResult = await ghCmdRetry(() => $`gh api repos/${owner}/${repo}/branches --paginate --jq .[].name`, { label: `list branches ${owner}/${repo}` });
+    // Issue #2135: `mirror: false`. Only the closest name is reported (below),
+    // yet the raw answer is every branch in the repository.
+    const listResult = await ghCmdRetry(() => $(QUIET_PROBE)`gh api repos/${owner}/${repo}/branches --paginate --jq .[].name`, { label: `list branches ${owner}/${repo}` });
     if (listResult.code === 0) {
       const branches = listResult.stdout
         .toString()

package/src/github.lib.mjs

@@ -19,7 +19,7 @@ import { buildCostInfoString } from './github-cost-info.lib.mjs';
 export { buildCostInfoString };
 // #1756: route gh exec calls through transient + rate-limit retry wrapper
 import { execGhWithRetry } from './github-rate-limit.lib.mjs';
-import { QUIET_PROBE } from './quiet-probe.lib.mjs'; // issue #2130: keep read-only probe payloads out of the attached log
+import { QUIET_PROBE } from './quiet-probe.lib.mjs'; // issues #2130, #2135: keep read-only probe payloads out of the attached log
 // Issue #1625: Named marker constants (single source of truth) + in-memory
 // tracking for tool-posted comments. See tool-comments.lib.mjs for design.
 import { SOLUTION_DRAFT_LOG_MARKER, SOLUTION_DRAFT_FAILED_MARKER, SOLUTION_DRAFT_FINISHED_WITH_ERRORS_MARKER, USAGE_LIMIT_REACHED_MARKER, NOW_WORKING_SESSION_IS_ENDED_MARKER, postTrackedComment, postTrackedCommentFromFile } from './tool-comments.lib.mjs';
@@ -1324,7 +1324,7 @@ export function isGitHubUrlType(url, types) {
  */
 export async function ghPrView({ prNumber, owner, repo, jsonFields = 'headRefName,body,number,mergeStateStatus,state,headRepositoryOwner' }) {
   try {
-    const prResult = await $`gh pr view ${prNumber} --repo ${owner}/${repo} --json ${jsonFields}`;
+    const prResult = await $(QUIET_PROBE)`gh pr view ${prNumber} --repo ${owner}/${repo} --json ${jsonFields}`;
     const stdout = prResult.stdout.toString();
     const stderr = prResult.stderr ? prResult.stderr.toString() : '';
     const code = prResult.code || 0;
@@ -1364,7 +1364,7 @@ export async function ghPrView({ prNumber, owner, repo, jsonFields = 'headRefNam
  */
 export async function ghIssueView({ issueNumber, owner, repo, jsonFields = 'number,title' }) {
   try {
-    const issueResult = await $`gh issue view ${issueNumber} --repo ${owner}/${repo} --json ${jsonFields}`;
+    const issueResult = await $(QUIET_PROBE)`gh issue view ${issueNumber} --repo ${owner}/${repo} --json ${jsonFields}`;
     const stdout = issueResult.stdout.toString();
     const stderr = issueResult.stderr ? issueResult.stderr.toString() : '';
     const code = issueResult.code || 0;

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

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) {

package/src/solve.keep-working.lib.mjs

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { QUIET_PROBE } from './quiet-probe.lib.mjs';
 import { ensureUseM } from './use-m-bootstrap.lib.mjs';
 
 /**
@@ -68,7 +69,8 @@ export const collectDeferredWorkSources = async ({ owner, repo, prNumber, result
 
   // 1. Pull request description
   try {
-    const prResult = await $`gh api repos/${owner}/${repo}/pulls/${prNumber} --jq '.body // ""'`;
+    // Issue #2135: `mirror: false` - the description is scanned here, not shown.
+    const prResult = await $(QUIET_PROBE)`gh api repos/${owner}/${repo}/pulls/${prNumber} --jq '.body // ""'`;
     if (prResult.code === 0) {
       const body = prResult.stdout.toString();
       if (body && body.trim()) {
@@ -86,7 +88,10 @@ export const collectDeferredWorkSources = async ({ owner, repo, prNumber, result
 
   // 3. Changed markdown documents (scan only added lines from the diff)
   try {
-    const filesResult = await $`gh api repos/${owner}/${repo}/pulls/${prNumber}/files --paginate`;
+    // Issue #2135: `mirror: false`. Every entry carries the file's patch, so
+    // this answer is as large as the pull request's diff - and it was being
+    // echoed into the log that gets attached to that same pull request.
+    const filesResult = await $(QUIET_PROBE)`gh api repos/${owner}/${repo}/pulls/${prNumber}/files --paginate`;
     if (filesResult.code === 0) {
       const files = JSON.parse(filesResult.stdout.toString() || '[]');
       for (const file of files) {

package/src/solve.minimal-restart-prompt.lib.mjs

@@ -9,6 +9,8 @@
  * @see case-studies/issue-661-session-resume-cost-optimization/
  */
 
+import { QUIET_PROBE } from './quiet-probe.lib.mjs';
+
 // Note: This module does not import $ directly
 // Functions receive $ as a parameter from the calling module
 // This ensures consistent command executor usage across the codebase
@@ -28,9 +30,11 @@ export const generateMinimalRestartPrompt = async (tempDir, $) => {
   const uncommittedFiles = gitStatus.stdout.toString().trim();
 
   // Get brief diff summaries (not full diffs to keep the prompt minimal)
-  const gitDiffStat = await $({ cwd: tempDir })`git diff --stat`;
+  // Issue #2135: `mirror: false` - the summaries go into the prompt below, so
+  // echoing them into the log only duplicates them into the attached log file.
+  const gitDiffStat = await $({ cwd: tempDir, ...QUIET_PROBE })`git diff --stat`;
   const unstagedDiffSummary = gitDiffStat.stdout.toString().trim();
-  const gitCachedDiffStat = await $({ cwd: tempDir })`git diff --cached --stat`;
+  const gitCachedDiffStat = await $({ cwd: tempDir, ...QUIET_PROBE })`git diff --cached --stat`;
   const stagedDiffSummary = gitCachedDiffStat.stdout.toString().trim();
   const summarySections = [];
   if (unstagedDiffSummary) summarySections.push(`Unstaged changes:\n${unstagedDiffSummary}`);
@@ -69,7 +73,11 @@ export const generateFullRestartPrompt = async (issueUrl, issueBody, prNumber, f
   const gitStatus = await $({ cwd: tempDir })`git status --porcelain`;
   const uncommittedFiles = gitStatus.stdout.toString().trim();
 
-  const gitDiff = await $({ cwd: tempDir })`git diff`;
+  // Issue #2135: `mirror: false`. This is the working tree's whole diff and it
+  // is embedded in the prompt below; mirroring it wrote a second copy into the
+  // session log, which is attached to the pull request and (with
+  // --development-log) committed into the branch the diff is taken from.
+  const gitDiff = await $({ cwd: tempDir, ...QUIET_PROBE })`git diff`;
   const fullDiff = gitDiff.stdout.toString();
 
   let prompt = `

package/src/solve.preparation.lib.mjs

@@ -4,6 +4,7 @@
  */
 
 import { wrapDollarWithGhRetry as _wrapDollarWithGhRetry } from './github-rate-limit.lib.mjs'; // rate-limit marker (#1726): gh API calls flow through $ wrapped by caller
+import { quietProbe } from './quiet-probe.lib.mjs';
 // Import feedback detection functionality
 const feedback = await import('./solve.feedback.lib.mjs');
 const { detectAndCountFeedback } = feedback;
@@ -45,7 +46,10 @@ export async function prepareFeedbackAndTimestamps({ tempDir = null, prNumber, b
 
     // Get the last comment's timestamp (if any)
     // Use --paginate to get all comments - GitHub API returns max 30 per page by default
-    const commentsResult = await $`gh api repos/${owner}/${repo}/issues/${issueNumber}/comments --paginate`;
+    // Issue #2135: `mirror: false`. Only the last comment's timestamp is read
+    // from this answer, but the answer itself is every comment body on the
+    // issue - tens of kilobytes echoed into the log on every run.
+    const commentsResult = await quietProbe($)`gh api repos/${owner}/${repo}/issues/${issueNumber}/comments --paginate`;
 
     if (commentsResult.code !== 0) {
       await log(`Warning: Failed to get comments: ${commentsResult.stderr ? commentsResult.stderr.toString() : 'Unknown error'}`, { level: 'warning' });

package/src/solve.progress-monitoring.lib.mjs

@@ -30,6 +30,7 @@ import { LIVE_PROGRESS_SECTION_START_MARKER, LIVE_PROGRESS_SECTION_END_MARKER, p
 import { writeSanitizedPublicationFile } from './token-sanitization.lib.mjs';
 
 import { wrapDollarWithGhRetry as _wrapDollarWithGhRetry } from './github-rate-limit.lib.mjs'; // rate-limit marker (#1726): gh API calls flow through $ wrapped by caller
+import { quietProbe } from './quiet-probe.lib.mjs'; // issue #2135: keep large read-only probe payloads out of the attached log
 /**
  * Configuration constants for progress monitoring
  */
@@ -280,7 +281,10 @@ export const createProgressMonitor = ({ owner, repo, prNumber, $, log, verbose =
       state.currentTodos = todos;
 
       // Fetch current PR description
-      const prData = await $`gh pr view ${prNumber} --repo ${owner}/${repo} --json body`;
+      // Issue #2135: `mirror: false`. This runs on every progress update and
+      // the answer is the whole pull-request description, which by then holds
+      // the progress section itself.
+      const prData = await quietProbe($)`gh pr view ${prNumber} --repo ${owner}/${repo} --json body`;
       const prInfo = JSON.parse(prData.stdout);
       let currentBody = prInfo.body || '';
 

package/src/solve.repository.lib.mjs

@@ -65,7 +65,8 @@ export const checkExistingForkOfRoot = async rootRepo => {
     // not to the shell, and command-stream quotes interpolated values itself - so
     // interpolating inside the quotes would leak shell quotes into the comparison.
     const forkFilter = `.[] | select(.owner.login == ${JSON.stringify(currentUser)}) | .full_name`;
-    const forksResult = await lib.ghCmdRetry(() => $`gh api repos/${rootRepo}/forks --paginate --jq ${forkFilter}`, { label: `check forks of ${rootRepo}` });
+    // Issue #2135: `mirror: false` - see the fork-name lookup below.
+    const forksResult = await lib.ghCmdRetry(() => $(QUIET_PROBE)`gh api repos/${rootRepo}/forks --paginate --jq ${forkFilter}`, { label: `check forks of ${rootRepo}` });
     if (forksResult.code !== 0) return null;
 
     const forks = forksResult.stdout
@@ -1225,7 +1226,9 @@ export const setupPrForkRemote = async (tempDir, argv, prForkOwner, repo, isCont
     // Issue #2119: the double quotes here are jq syntax, so the expression is
     // built in JS and interpolated as one already-escaped argument.
     const forkNameFilter = `.[] | select(.owner.login == ${JSON.stringify(prForkOwner)}) | .name`;
-    const forksResult = await $`gh api repos/${owner}/${repo}/forks --paginate --jq ${forkNameFilter}`;
+    // Issue #2135: `mirror: false` - a popular repository has thousands of
+    // forks, and only the matching name is used.
+    const forksResult = await $(QUIET_PROBE)`gh api repos/${owner}/${repo}/forks --paginate --jq ${forkNameFilter}`;
     if (forksResult.code === 0 && forksResult.stdout) {
       const forkName = forksResult.stdout.toString().trim().split('\n')[0]; // Take first match
       if (forkName) {

package/src/solve.results.lib.mjs

@@ -407,7 +407,9 @@ export const cleanupClaudeFile = async (tempDir, branchName, claudeCommitHash =
     // APPROACH 3: Check for modifications before reverting (proactive detection)
     // This is the main strategy - detect if the file was modified after initial commit
     await log(`   Checking if ${fileName} was modified since initial commit...`, { verbose: true });
-    const diffResult = await $({ cwd: tempDir })`git diff ${commitToRevert} HEAD -- ${fileName} 2>&1`;
+    // Issue #2135: `mirror: false`. Only "is it non-empty" is asked here, and
+    // the answer is a file's whole diff.
+    const diffResult = await $({ cwd: tempDir, ...QUIET_PROBE })`git diff ${commitToRevert} HEAD -- ${fileName} 2>&1`;
 
     if (diffResult.stdout && diffResult.stdout.trim()) {
       // File was modified after initial commit - use manual approach to avoid conflicts
@@ -746,7 +748,8 @@ export const verifyResults = async (owner, repo, branchName, issueNumber, prNumb
     // First, get all PRs from our branch
     // IMPORTANT: Use --state all to find PRs that may have been merged during the session (Issue #1008)
     // Without --state all, gh pr list only returns OPEN PRs, missing merged ones
-    const allBranchPrsResult = await $`gh pr list --repo ${owner}/${repo} --head ${branchName} --state all --json number,url,createdAt,headRefName,title,state,updatedAt,isDraft`;
+    // Issue #2135: `mirror: false` - the pull requests found are named below.
+    const allBranchPrsResult = await $(QUIET_PROBE)`gh pr list --repo ${owner}/${repo} --head ${branchName} --state all --json number,url,createdAt,headRefName,title,state,updatedAt,isDraft`;
 
     if (allBranchPrsResult.code !== 0) {
       await log('  ⚠️  Failed to check pull requests');
@@ -819,7 +822,7 @@ export const verifyResults = async (owner, repo, branchName, issueNumber, prNumb
             // "1 file(s) modified, 1 line(s) added" for a pull request that
             // changed nothing, because the stats were never checked for being
             // empty.
-            const changeStats = await getPullRequestChangeStats({ owner, repo, prNumber: pr.number, $ });
+            const changeStats = await getPullRequestChangeStats({ owner, repo, prNumber: pr.number, $, log });
             if (!changeStats.hasChanges) {
               await log(`  ⚠️  PR #${pr.number} has an empty diff - the description will say so instead of claiming changes`, { level: 'warning' });
             }
@@ -948,7 +951,9 @@ Fixes ${issueRef}
 
     // Get all comments and filter them
     // Use --paginate to get all comments - GitHub API returns max 30 per page by default
-    const allCommentsResult = await $`gh api repos/${owner}/${repo}/issues/${issueNumber}/comments --paginate`;
+    // Issue #2135: `mirror: false` - the counts below are the report; the raw
+    // answer is every comment body on the issue.
+    const allCommentsResult = await $(QUIET_PROBE)`gh api repos/${owner}/${repo}/issues/${issueNumber}/comments --paginate`;
 
     if (allCommentsResult.code !== 0) {
       await log('  ⚠️  Failed to check comments');
@@ -1209,7 +1214,7 @@ export const checkForAiCreatedComments = async (sessionStartTime, owner, repo, p
     // Check comments on the PR first (if we have a PR)
     if (prNumber) {
       // Check PR conversation comments
-      const prCommentsResult = await $`gh api repos/${owner}/${repo}/issues/${prNumber}/comments --paginate`;
+      const prCommentsResult = await $(QUIET_PROBE)`gh api repos/${owner}/${repo}/issues/${prNumber}/comments --paginate`;
       if (prCommentsResult.code === 0) {
         const prComments = JSON.parse(prCommentsResult.stdout.toString().trim() || '[]');
         const newPrComments = filterNewAiComments(prComments, 'pr');
@@ -1220,7 +1225,7 @@ export const checkForAiCreatedComments = async (sessionStartTime, owner, repo, p
       }
 
       // Check PR review comments (inline code comments)
-      const reviewCommentsResult = await $`gh api repos/${owner}/${repo}/pulls/${prNumber}/comments --paginate`;
+      const reviewCommentsResult = await $(QUIET_PROBE)`gh api repos/${owner}/${repo}/pulls/${prNumber}/comments --paginate`;
       if (reviewCommentsResult.code === 0) {
         const reviewComments = JSON.parse(reviewCommentsResult.stdout.toString().trim() || '[]');
         const newReviewComments = filterNewAiComments(reviewComments, 'review');
@@ -1233,7 +1238,7 @@ export const checkForAiCreatedComments = async (sessionStartTime, owner, repo, p
 
     // Check issue comments (if different from PR number or no PR)
     if (issueNumber && issueNumber !== prNumber) {
-      const issueCommentsResult = await $`gh api repos/${owner}/${repo}/issues/${issueNumber}/comments --paginate`;
+      const issueCommentsResult = await $(QUIET_PROBE)`gh api repos/${owner}/${repo}/issues/${issueNumber}/comments --paginate`;
       if (issueCommentsResult.code === 0) {
         const issueComments = JSON.parse(issueCommentsResult.stdout.toString().trim() || '[]');
         const newIssueComments = filterNewAiComments(issueComments, 'issue');
@@ -1413,7 +1418,7 @@ export const maybeAttachWorkingSessionSummary = async ({ argv, resultSummary, wo
       : null);
   // Issue #2119: a summary posted on a pull request that changed nothing must
   // say so, instead of reading as a report of completed work.
-  const changeStats = prNumber ? await getPullRequestChangeStats({ owner, repo, prNumber, $ }) : null;
+  const changeStats = prNumber ? await getPullRequestChangeStats({ owner, repo, prNumber, $, log }) : null;
 
   // Issue #2132: the summary carries no cost/budget block. `resolvedBudgetStatsData`
   // is computed only so the caller can reuse it for this session's log comment.

package/src/task.mjs

@@ -3,6 +3,7 @@
 import crypto from 'crypto';
 import path from 'path';
 import { spawn } from 'child_process';
+import { describeChildExit } from './child-exit.lib.mjs';
 import { promises as fs } from 'fs';
 import { buildStartAgentArgs, resolveStartAgentCommand } from './task.agent-command.lib.mjs';
 import { getDefaultTaskModel, parseTaskArguments } from './task.config.lib.mjs';
@@ -112,8 +113,8 @@ function runCommand(command, args, options = {}) {
     child.on('error', error => {
       resolve({ code: 1, stdout, stderr: stderr || error.message });
     });
-    child.on('close', code => {
-      resolve({ code, stdout, stderr });
+    child.on('close', (code, signal) => {
+      resolve({ code, stdout, stderr, signal });
     });
   });
 }
@@ -122,7 +123,8 @@ async function commandOutput(command, args, options = {}) {
   const result = await runCommand(command, args, options);
   if (result.code !== 0) {
     const output = `${result.stderr || ''}${result.stdout || ''}`.trim();
-    throw new Error(output || `${command} exited with code ${result.code}`);
+    // Issue #2135: `describeChildExit` names a signal instead of "code null".
+    throw new Error(output || describeChildExit({ command, code: result.code, signal: result.signal }));
   }
   return result.stdout.trim();
 }

package/src/telegram-command-execution.lib.mjs

@@ -1,4 +1,5 @@
 import { spawn } from 'child_process';
+import { describeChildExit } from './child-exit.lib.mjs';
 import { promisify } from 'util';
 import { exec as execCallback } from 'child_process';
 import { t } from './i18n.lib.mjs';
@@ -57,7 +58,7 @@ function executeWithCommand(startScreenCmd, command, args, verbose = false) {
       });
     });
 
-    child.on('close', code => {
+    child.on('close', (code, signal) => {
       if (code === 0) {
         resolve({
           success: true,
@@ -67,7 +68,9 @@ function executeWithCommand(startScreenCmd, command, args, verbose = false) {
         resolve({
           success: false,
           output: stdout,
-          error: stderr || `Command exited with code ${code}`,
+          // Issue #2135: name the signal, so an out-of-memory abort is not
+          // reported as "code null".
+          error: stderr || describeChildExit({ command: 'Command', code, signal }),
         });
       }
     });