@link-assistant/hive-mind 2.11.8 → 2.11.10

package/CHANGELOG.md

@@ -1,5 +1,57 @@
 # @link-assistant/hive-mind
 
+## 2.11.10
+
+### Patch Changes
+
+- 8c8844a: Stop treating agent CLI stderr as a JSON protocol stream (issue #2136).
+
+  `codex exec --json` writes its NDJSON protocol to stdout only; its stderr carries
+  OTEL tracing whose `codex.tool_result` records dump the raw stdout of every
+  command Codex runs. When the task itself drove another agent CLI, that dump
+  replayed NDJSON byte-identical to Codex's own protocol, so an echoed
+  `turn.started` was counted as Codex's own and the completion gate failed a run
+  that had actually finished — posting a "Solution Draft Failed" comment on a pull
+  request that was complete and later merged.
+
+  Codex now parses only stdout as protocol; protocol-shaped JSON seen on stderr is
+  reported separately (`🪞 Echoed protocol-shaped lines on codex stderr`) and never
+  affects event counts, session id, token usage or error detection. The completion
+  gate additionally uses the ordered turn lifecycle (`🔁 Codex turn lifecycle`)
+  instead of comparing counts, so a stray `turn.started` can no longer fail a
+  completed run while a genuinely truncated turn still does. The same stream
+  separation is applied to qwen (whose stderr echo could raise a false error and
+  whose two streams shared one line buffer), and OpenCode now reports how many JSON
+  records it parsed from stderr.
+
+## 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.10",
   "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/codex-health.lib.mjs

@@ -218,6 +218,26 @@ export const getCodexPluginProvisioningHealth = (codexJsonState, { capabilityPre
 // both observed in the captured runs at exit_code 0) would be wrongly failed.
 // Disk pressure is surfaced only as supporting *diagnostics* explaining why a
 // session was likely cut off, never as the sole reason to fail a completed turn.
+// Issue #2136: the count comparison above is only sound when every counted
+// `turn.started` is codex's own. It is not: under `--verbose` codex's stderr
+// carries OTEL records that dump the raw stdout of each command it ran, so a task
+// that drives another agent CLI replays that agent's `turn.started` into our
+// stream. One echoed line was enough to make turn.started=2 vs turn.completed=1
+// and fail a run that had finished successfully (formal-ai PR #913 was open with
+// green CI). codex.lib.mjs now keeps stderr out of the protocol counters, and the
+// gate itself asks the order-aware question — "was the LAST lifecycle event a
+// start?" — so a stray extra `turn.started` from any future echo path can no
+// longer flip a completed session to failed, while a genuine cut-off mid-turn
+// (the #1990 shape: the stream ends on `turn.started`) still fails.
+const isIncompleteTurnLifecycle = (turnLifecycle, { turnStarted, turnCompleted, turnFailed }) => {
+  if (!Array.isArray(turnLifecycle) || turnLifecycle.length === 0) {
+    // Callers that hand-build a state without an ordered lifecycle keep the
+    // original count rule.
+    return turnCompleted + turnFailed < Math.max(turnStarted, 1);
+  }
+  return turnLifecycle.at(-1) === 'turn.started';
+};
+
 export const getCodexCompletionHealth = (codexJsonState, { lastMessage = '' } = {}) => {
   const eventCounts = codexJsonState?.eventCounts || {};
   const turnStarted = eventCounts['turn.started'] || 0;
@@ -232,7 +252,7 @@ export const getCodexCompletionHealth = (codexJsonState, { lastMessage = '' } =
 
   // A started turn that never completed or failed = the process was cut off
   // mid-turn (OOM / disk-full / container teardown) even though it exited 0.
-  const incompleteSession = hadActivity && turnCompleted + turnFailed < Math.max(turnStarted, 1);
+  const incompleteSession = hadActivity && isIncompleteTurnLifecycle(codexJsonState?.turnLifecycle, { turnStarted, turnCompleted, turnFailed });
 
   // Diagnostic-only disk-pressure hints (never an independent failure gate).
   const diskEvidence = [];

package/src/codex.lib.mjs

@@ -338,7 +338,21 @@ const upsertCodexItemError = (itemErrors, item) => {
   });
 };
 
-export const parseCodexExecJsonOutput = (output, state = {}, requestedModelId = null) => {
+// Issue #2136: `codex exec --json` writes its NDJSON protocol to **stdout** only.
+// Its stderr carries OTEL tracing text (RUST_LOG=debug under --verbose), and each
+// `codex.tool_result` record dumps the raw stdout of the command codex just ran —
+// so a task driving another agent CLI replays that agent's NDJSON verbatim inside
+// the trace. Feeding stderr through this parser counted the nested agent's
+// `turn.started` as codex's own, and the #1990 completion gate then failed a run
+// that had actually completed (see docs/case-studies/issue-2136).
+//
+// Fix: only stdout is trusted as protocol. Stderr is still scanned for the
+// text-only diagnostics that legitimately live there (token/model diagnostics,
+// the #2102 plugin-install rejection), but protocol-shaped JSON found there is
+// counted into `telemetryEventCounts` and otherwise ignored — it never touches
+// eventCounts, sessionId, usage or the error buckets.
+export const parseCodexExecJsonOutput = (output, state = {}, requestedModelId = null, { source = 'stdout' } = {}) => {
+  const isProtocolStream = source === 'stdout';
   const nextState = {
     sessionId: state.sessionId || null,
     authError: state.authError || false,
@@ -359,6 +373,13 @@ export const parseCodexExecJsonOutput = (output, state = {}, requestedModelId =
     pluginInstallRejections: state.pluginInstallRejections || [],
     observedUsageFieldSets: state.observedUsageFieldSets || [],
     observedModelDiagnosticPaths: state.observedModelDiagnosticPaths || [],
+    // Issue #2136: protocol-shaped JSON seen on a non-protocol stream (telemetry
+    // echo), kept for diagnostics only.
+    telemetryEventCounts: state.telemetryEventCounts || {},
+    // Issue #2136: ordered turn lifecycle from the protocol stream, so the
+    // completion gate can ask "did the last turn finish?" instead of comparing
+    // counts that an echoed `turn.started` can skew.
+    turnLifecycle: state.turnLifecycle || [],
   };
 
   nextState.tokenUsage.tokenFieldAvailability ||= createCodexTokenFieldAvailability();
@@ -396,7 +417,18 @@ export const parseCodexExecJsonOutput = (output, state = {}, requestedModelId =
     if (data === null || typeof data !== 'object') continue;
 
     const eventType = typeof data.type === 'string' ? data.type : 'unknown';
+
+    // Issue #2136: a protocol-shaped object on a non-protocol stream is echoed
+    // telemetry, never a codex event. Count it for diagnostics and move on.
+    if (!isProtocolStream) {
+      nextState.telemetryEventCounts[eventType] = (nextState.telemetryEventCounts[eventType] || 0) + 1;
+      continue;
+    }
+
     nextState.eventCounts[eventType] = (nextState.eventCounts[eventType] || 0) + 1;
+    if (eventType === 'turn.started' || eventType === 'turn.completed' || eventType === 'turn.failed') {
+      nextState.turnLifecycle.push(eventType);
+    }
 
     if (eventType === 'thread.started' && typeof data.thread_id === 'string' && !nextState.sessionId) {
       nextState.sessionId = data.thread_id;
@@ -983,6 +1015,8 @@ export const executeCodexCommand = async params => {
         pluginInstallRejections: [],
         observedUsageFieldSets: [],
         observedModelDiagnosticPaths: [],
+        telemetryEventCounts: {},
+        turnLifecycle: [],
       };
 
       // Issue #2119: a process chunk boundary can fall in the middle of an
@@ -1001,7 +1035,7 @@ export const executeCodexCommand = async params => {
           lastMessage = raw;
           const output = codexStdoutLines.write(raw);
 
-          codexJsonState = parseCodexExecJsonOutput(output, codexJsonState, mappedModel);
+          codexJsonState = parseCodexExecJsonOutput(output, codexJsonState, mappedModel, { source: 'stdout' });
           await baseBranchCommandIntervention.handleCommandExecutions(codexJsonState.commandExecutions);
 
           if (interactiveHandler || progressMonitor) {
@@ -1044,7 +1078,8 @@ export const executeCodexCommand = async params => {
             await log(rawError, { stream: 'stderr' });
           }
           const errorOutput = codexStderrLines.write(rawError);
-          codexJsonState = parseCodexExecJsonOutput(errorOutput, codexJsonState, mappedModel);
+          // Issue #2136: stderr is telemetry/tracing text, not the codex protocol.
+          codexJsonState = parseCodexExecJsonOutput(errorOutput, codexJsonState, mappedModel, { source: 'stderr' });
           await baseBranchCommandIntervention.handleCommandExecutions(codexJsonState.commandExecutions);
         } else if (chunk.type === 'exit') {
           exitCode = chunk.code;
@@ -1052,9 +1087,12 @@ export const executeCodexCommand = async params => {
       }
 
       // Release any line that was still being assembled when the stream ended.
-      for (const remaining of [codexStdoutLines.flush(), codexStderrLines.flush()]) {
+      for (const [source, remaining] of [
+        ['stdout', codexStdoutLines.flush()],
+        ['stderr', codexStderrLines.flush()],
+      ]) {
         if (!remaining.trim()) continue;
-        codexJsonState = parseCodexExecJsonOutput(remaining, codexJsonState, mappedModel);
+        codexJsonState = parseCodexExecJsonOutput(remaining, codexJsonState, mappedModel, { source });
         await baseBranchCommandIntervention.handleCommandExecutions(codexJsonState.commandExecutions);
       }
 

package/src/codex.run-diagnostics.lib.mjs

@@ -86,6 +86,17 @@ export const buildCodexRunDiagnostics = ({ state = {}, exitCode = null, mappedMo
   if (Object.keys(state.eventCounts || {}).length > 0) push(`📊 Codex JSON events: ${counts(state.eventCounts)}`);
   if (Object.keys(state.itemTypeCounts || {}).length > 0) push(`📦 Codex item types: ${counts(state.itemTypeCounts)}`);
 
+  // Issue #2136: protocol-shaped JSON that arrived on codex's stderr (OTEL
+  // `codex.tool_result` records replay the raw stdout of every command codex
+  // runs, so a task driving another agent CLI replays that agent's NDJSON). These
+  // lines are deliberately NOT counted as codex events; surfacing them keeps the
+  // discrepancy between "events codex emitted" and "protocol lines seen in the
+  // log" explainable when a run is investigated after the fact.
+  if (Object.keys(state.telemetryEventCounts || {}).length > 0) {
+    push(`🪞 Echoed protocol-shaped lines on codex stderr (ignored, not codex events): ${counts(state.telemetryEventCounts)}`);
+  }
+  if (state.turnLifecycle?.length > 0) push(`🔁 Codex turn lifecycle: ${state.turnLifecycle.join(' → ')}`);
+
   const usage = state.tokenUsage || {};
   if (usage.stepCount > 0) {
     push(`📈 Codex usage from turn.completed: ${usage.inputTokens.toLocaleString()} input, ${usage.cacheReadTokens.toLocaleString()} cache read, ${usage.outputTokens.toLocaleString()} output across ${usage.stepCount} turn(s)`);

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;