@link-assistant/hive-mind 2.11.7 → 2.11.9

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # @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
+
+- 881e604: Stop announcing kills that did not happen, and say exactly what happened when one did. Docker sets `State.OOMKilled` when any process in the container cgroup is OOM-killed, so a container whose helper process died keeps running and can still exit 0 — Hive Mind treated the flag as terminal and reported a task as "killed — out of memory or forced kill (SIGKILL)" while it went on working for another 3.5 hours and merged its pull request with nothing said there. The flag is now an observation: the log footer wins, then container liveness, and only a dead container with no footer is reported as killed.
+
+  Every kill now carries a diagnosis built from evidence already collected — the resource markers in the working-session log, cgroup v2 `memory.events`, `/proc/meminfo`, disk usage and the kernel OOM report — so the message names out of memory, disk exhaustion or a forced kill instead of guessing, and names the process the kernel killed. A session that survived the event completes with a `recovered from out of memory` / `recovered from forced kill` warning (en/ru/zh/hi) instead of reading as a plain success, and the same report is posted to the pull request; the intermediate working-session log is uploaded alongside it only when `--attach-logs` is enabled. Behaviour is one option honoured identically by the bot and by `solve`: `--on-session-kill=report|resume` (env `HIVE_MIND_ON_SESSION_KILL`), defaulting to today's `report`. Under `resume`, a killed session is restarted through the same isolation backend from the last tool session id found in its own log, the new session is tracked like any other, and both the Telegram completion and the pull-request notice name it; `--session-kill-resume-attempts` (default 1) caps how many recovery sessions one killed session may produce, and a session stopped on purpose is never restarted.
+
 ## 2.11.7
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "2.11.7",
+  "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/locales/en.lino

@@ -658,6 +658,16 @@ en
       label "Duration"
     session
       label "Session"
+      recovered
+        oom "recovered from out of memory"
+        kill "recovered from forced kill"
+        at "The event was observed at {{observedAt}}; the work session kept running and completed."
+        resumed "A new working session was started to recover from the kill."
+      kill
+        cause "Cause"
+        diagnostics "Kill diagnostics"
+        resumed "🔄 A new working session was started to recover from this kill: {{sessionId}}"
+        resumed_attempt "🔄 A new working session was started to recover from this kill (attempt {{attempt}}): {{sessionId}}"
     isolation
       label "Isolation"
     error

package/src/locales/hi.lino

@@ -658,6 +658,16 @@ hi
       label "अवधि"
     session
       label "सत्र"
+      recovered
+        oom "मेमोरी समाप्त होने से पुनर्प्राप्त"
+        kill "जबरन समाप्ति से पुनर्प्राप्त"
+        at "यह घटना {{observedAt}} पर देखी गई; कार्य सत्र चलता रहा और पूरा हुआ।"
+        resumed "समाप्ति से पुनर्प्राप्ति हेतु नया कार्य सत्र शुरू किया गया।"
+      kill
+        cause "कारण"
+        diagnostics "समाप्ति निदान"
+        resumed "🔄 इस समाप्ति से पुनर्प्राप्ति हेतु नया कार्य सत्र शुरू किया गया: {{sessionId}}"
+        resumed_attempt "🔄 इस समाप्ति से पुनर्प्राप्ति हेतु नया कार्य सत्र शुरू किया गया (प्रयास {{attempt}}): {{sessionId}}"
     isolation
       label "Isolation"
     error