@link-assistant/hive-mind 2.0.24 → 2.0.25

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @link-assistant/hive-mind
 
+## 2.0.25
+
+### Patch Changes
+
+- 148ca23: Fix exit-0-but-incomplete runs being reported as success under docker isolation (#1990). A `solve` run whose AI tool exited 0 while its session was cut off mid-run (e.g. the container ran out of disk) is now registered as a failure instead of a false success: codex requires its paired `turn.started`/`turn.completed` lifecycle, and gemini and qwen now require their terminal `result` event (claude already gated on it). A flagged failure preserves the AI session for a context-preserving retry and returns a non-zero exit so the docker container filesystem is kept for inspection. Disk-exhaustion strings are surfaced only as diagnostics, never as an independent failure gate, to avoid the #1955 echo false positive.
+
+  This also refreshes dependencies and picks up the upstream half of the #1990 fix. The
+  `start-command` pin in `Dockerfile`/`Dockerfile.dind` is bumped `0.30.1 → 0.30.2`,
+  which delivers [link-foundation/start#144](https://github.com/link-foundation/start/issues/144):
+  detached/isolated docker runs now surface the container's `OOMKilled` status and
+  preserve an abnormally-terminated container's filesystem for inspection instead of
+  auto-removing it. npm dependencies and devDependencies are updated to their latest
+  compatible versions (notably ESLint 9 → 10, which enables the `no-useless-assignment`
+  and `preserve-caught-error` recommended rules — all newly-flagged sites were fixed).
+  `jscpd` is intentionally held at `^4.0.5` because its 5.x line changes the
+  duplication baseline (it analyzes a wider file set, reporting 12.2% vs 10.7% on the
+  same tree) and would otherwise force weakening the duplication gate; this is a tooling
+  behavior change, not new duplication.
+
 ## 2.0.24
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "2.0.24",
+  "version": "2.0.25",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",
@@ -57,30 +57,30 @@
     "*.md"
   ],
   "devDependencies": {
-    "@changesets/cli": "^2.27.0",
-    "@eslint/js": "^9.35.0",
-    "eslint": "^9.35.0",
+    "@changesets/cli": "^2.31.0",
+    "@eslint/js": "^10.0.1",
+    "eslint": "^10.5.0",
     "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-prettier": "^5.5.4",
+    "eslint-plugin-prettier": "^5.5.6",
     "husky": "^9.1.7",
     "jscpd": "^4.0.5",
-    "lint-staged": "^16.2.7",
-    "prettier": "^3.6.2",
+    "lint-staged": "^17.0.8",
+    "prettier": "^3.8.5",
     "test-anywhere": "^0.9.1"
   },
   "dependencies": {
-    "@secretlint/core": "^11.2.5",
-    "@secretlint/secretlint-rule-preset-recommend": "^11.2.5",
-    "@sentry/node": "^10.15.0",
-    "@sentry/profiling-node": "^10.15.0",
-    "agent-commander": "^0.6.1",
-    "dayjs": "^1.11.19",
+    "@secretlint/core": "^13.0.2",
+    "@secretlint/secretlint-rule-preset-recommend": "^13.0.2",
+    "@sentry/node": "^10.62.0",
+    "@sentry/profiling-node": "^10.62.0",
+    "agent-commander": "^0.8.0",
+    "dayjs": "^1.11.21",
     "decimal.js-light": "^2.5.1",
     "lino-arguments": "^0.3.0",
     "lino-i18n": "^0.1.1",
-    "lino-objects-codec": "^0.3.6",
-    "secretlint": "^11.2.5",
-    "semver": "^7.7.3",
+    "lino-objects-codec": "^0.4.0",
+    "secretlint": "^13.0.2",
+    "semver": "^7.8.5",
     "tinyld": "^1.3.4"
   },
   "lint-staged": {

package/src/agent-commander.lib.mjs

@@ -91,7 +91,7 @@ const getAgentCommander = async () => {
   try {
     return await import('agent-commander');
   } catch (error) {
-    throw new Error(`agent-commander is not installed or cannot be loaded. Install it with: npm install agent-commander\nOriginal error: ${error.message}`);
+    throw new Error(`agent-commander is not installed or cannot be loaded. Install it with: npm install agent-commander\nOriginal error: ${error.message}`, { cause: error });
   }
 };
 

package/src/auto-language.lib.mjs

@@ -19,7 +19,7 @@ function detectByScript(word) {
 
 export function detectWordLanguage(word, detector = detectLanguage) {
   if (!word || typeof word !== 'string') return null;
-  let detected = null;
+  let detected;
   try {
     detected = detector(word);
   } catch {

package/src/claude-quiet-config.lib.mjs

@@ -77,7 +77,7 @@ export function resolveClaudeLanguageSetting(locale) {
 
 export const ensureClaudeQuietConfig = async ({ settingsPath, log, workLanguage = null } = {}) => {
   const resolvedPath = settingsPath || path.join(os.homedir(), '.claude', 'settings.json');
-  let settings = {};
+  let settings;
   try {
     const content = await fs.readFile(resolvedPath, 'utf-8');
     const parsed = JSON.parse(content);

package/src/claude.lib.mjs

@@ -528,7 +528,7 @@ export const calculateSessionTokens = async (sessionId, tempDir, resultModelUsag
       compactifications: compactifications.length > 0 ? compactifications : null,
     };
   } catch (readError) {
-    throw new Error(`Failed to read session file: ${readError.message}`);
+    throw new Error(`Failed to read session file: ${readError.message}`, { cause: readError });
   }
 };
 // Extracted to claude.stderr.lib.mjs (Issue #477, #1337)

package/src/cleanup.mjs

@@ -372,7 +372,7 @@ async function main() {
     if (!options.force) {
       console.log(`\n⚠️  This will permanently delete ${classified.remove.length} entries (${formatBytes(totals.removeBytes)}) and remove ${dockerIsolationPlan.remove.length} Docker isolation containers.`);
       console.log('Type "yes" to confirm, or Ctrl+C to cancel:');
-      let answer = '';
+      let answer;
       try {
         answer = await readConfirmationLine({ prompt: '> ' });
       } catch {

package/src/cleanup.os.lib.mjs

@@ -756,7 +756,7 @@ export async function listSessionTasks(options = {}) {
     return [];
   }
 
-  let sessions = [];
+  let sessions;
   try {
     sessions = await listIsolationSessions(verbose);
   } catch {

package/src/codex-health.lib.mjs

@@ -0,0 +1,191 @@
+// Codex run-health analysis helpers.
+//
+// Extracted from codex.lib.mjs (which exceeded the 1500-line max-lines budget).
+// These functions inspect the parsed `codex exec --json` event state and decide
+// whether a run genuinely succeeded:
+//   - getCodexErrorEventSummary: classifies stray error events, suppressing the
+//     #1955 echoed-fixture false positives once a turn has completed.
+//   - getCodexCompletionHealth: the #1990 turn-lifecycle gate that flags exit-0
+//     runs cut off mid-turn (e.g. by docker disk exhaustion) as unhealthy.
+//
+// Both are re-exported from codex.lib.mjs for backward compatibility, so existing
+// importers (and tests) can keep importing them from either module.
+
+import { isENOSPC } from './lib.mjs';
+
+const unwrapCodexErrorMessage = value => {
+  if (!value) return '';
+  if (typeof value !== 'string') {
+    if (typeof value?.error?.message === 'string') return unwrapCodexErrorMessage(value.error.message);
+    if (typeof value?.message === 'string') return unwrapCodexErrorMessage(value.message);
+    return String(value);
+  }
+
+  let text = value.trim();
+  for (let i = 0; i < 3; i++) {
+    if (!text.startsWith('{') && !text.startsWith('[')) break;
+    try {
+      const parsed = JSON.parse(text);
+      if (typeof parsed?.error?.message === 'string') return unwrapCodexErrorMessage(parsed.error.message);
+      if (typeof parsed?.message === 'string') {
+        text = parsed.message.trim();
+        continue;
+      }
+      return JSON.stringify(parsed);
+    } catch {
+      break;
+    }
+  }
+  return text;
+};
+
+const isNonFatalCodexItemErrorMessage = message => /^in-process app-server event stream lagged; dropped \d+ events?$/i.test(message || '');
+
+export const getCodexErrorEventSummary = codexJsonState => {
+  const events = [];
+  const ignoredEvents = [];
+
+  // Issue #1955: When the codex turn genuinely completed (a `turn.completed`
+  // event was observed) and codex never emitted a `turn.failed`, the session
+  // SUCCEEDED. Any stray top-level `error` (stream) or nested item `error` event
+  // in that case is non-fatal and must not fail the run. Two things produce such
+  // strays:
+  //   1. A transient error codex itself retried/recovered from before completing
+  //      the turn (e.g. a momentary stream blip).
+  //   2. Echoed content that merely *looks* like a codex protocol event. The
+  //      codex CLI prints OTEL telemetry (`codex_otel.log_only`,
+  //      event.name="codex.tool_result") containing a raw `Output:` dump of each
+  //      command's stdout. When a command prints a line shaped like a protocol
+  //      event — e.g. a printed NDJSON fixture line
+  //      `{"type":"error","message":"Network lookup skipped in fixture"}` — our
+  //      line-by-line parser misreads it as a genuine codex stream error and
+  //      fails an otherwise-successful run. This was the exact false positive in
+  //      issue #1955 (codex finished, working tree clean, CI passed, yet the run
+  //      was reported failed).
+  // `turn.failed` is the authoritative failure signal, so it is NEVER suppressed
+  // here; only non-`turn` error events are gated on turn completion.
+  const turnCompleted = (codexJsonState?.eventCounts?.['turn.completed'] || 0) > 0;
+  const turnFailed = (codexJsonState?.turnFailures?.length || 0) > 0;
+  const sessionSucceeded = turnCompleted && !turnFailed;
+
+  const addEvents = (type, items = []) => {
+    for (const item of items) {
+      const message = unwrapCodexErrorMessage(item?.message);
+      const event = { type, message: message || 'Codex emitted an error event' };
+      if (type === 'item' && isNonFatalCodexItemErrorMessage(message)) {
+        ignoredEvents.push({
+          ...event,
+          reason: 'Codex app-server backpressure warning; the turn can still complete successfully',
+        });
+        continue;
+      }
+      if (type !== 'turn' && sessionSucceeded) {
+        ignoredEvents.push({
+          ...event,
+          reason: 'Codex turn completed successfully with no turn.failed; stray non-turn error event is non-fatal (Issue #1955)',
+        });
+        continue;
+      }
+      events.push(event);
+    }
+  };
+
+  addEvents('item', codexJsonState?.itemErrors);
+  addEvents('turn', codexJsonState?.turnFailures);
+  addEvents('stream', codexJsonState?.streamErrors);
+
+  const countByType = items => ({
+    item: items.filter(item => item.type === 'item').length,
+    turn: items.filter(item => item.type === 'turn').length,
+    stream: items.filter(item => item.type === 'stream').length,
+  });
+
+  return {
+    hasError: events.length > 0,
+    message: events[0]?.message || null,
+    events,
+    ignoredEvents,
+    counts: countByType(events),
+    ignoredCounts: countByType(ignoredEvents),
+    observedCounts: {
+      item: codexJsonState?.itemErrors?.length || 0,
+      turn: codexJsonState?.turnFailures?.length || 0,
+      stream: codexJsonState?.streamErrors?.length || 0,
+    },
+  };
+};
+
+// Issue #1990: A Codex run can exit 0 with no fatal `turn.failed`/error event yet
+// still be fundamentally broken. Under docker isolation two long-running
+// `solve --tool codex` tasks reported SUCCESS (Exit Code: 0) while their
+// containers had run out of disk: cargo builds died with "No space left on
+// device" / exit 101, no commits were produced, and — critically — the codex
+// turn was never completed (the process was cut off mid-turn). Because the exit
+// code was 0 and codex emitted no `turn.failed`, executeCodexCommand declared
+// success, which under docker isolation also discarded the container filesystem
+// we needed to inspect and retry from.
+//
+// The authoritative, echo-proof signal is codex's own turn lifecycle: `codex
+// exec` emits a paired `turn.started`/`turn.completed` for every turn (a failed
+// turn emits `turn.failed`). When the process ends with started turns that
+// neither completed nor failed, the session is INCOMPLETE regardless of the exit
+// code. Both captured failures had turn.started=1, turn.completed=0,
+// turn.failed=0 (see docs/case-studies/issue-1990).
+//
+// Disk-exhaustion strings ("No space left on device", ENOSPC) are deliberately
+// NOT used as an independent failure gate: codex echoes the stdout of every
+// command it runs back into its own stream (see issue #1955), so a target repo
+// that merely prints or works on that phrase (e.g. a `sed`/`cat` of a saved log,
+// 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.
+export const getCodexCompletionHealth = (codexJsonState, { lastMessage = '' } = {}) => {
+  const eventCounts = codexJsonState?.eventCounts || {};
+  const turnStarted = eventCounts['turn.started'] || 0;
+  const turnCompleted = eventCounts['turn.completed'] || 0;
+  const turnFailed = codexJsonState?.turnFailures?.length || 0;
+  const commandExecutions = codexJsonState?.commandExecutions || [];
+
+  // hadActivity = codex actually began doing work, so a genuinely empty stream
+  // (no turns, no commands) is never spuriously flagged — we only fail when work
+  // started but never finished.
+  const hadActivity = turnStarted > 0 || commandExecutions.length > 0 || (eventCounts['item.completed'] || 0) > 0;
+
+  // 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);
+
+  // Diagnostic-only disk-pressure hints (never an independent failure gate).
+  const diskEvidence = [];
+  const addDiskEvidence = (source, text) => {
+    if (text && isENOSPC(text)) {
+      diskEvidence.push({ source, text: String(text).replace(/\s+/g, ' ').trim().slice(0, 300) });
+    }
+  };
+  for (const exec of commandExecutions) addDiskEvidence(`command:${exec.command || exec.id || 'unknown'}`, exec.aggregatedOutput);
+  for (const streamError of codexJsonState?.streamErrors || []) addDiskEvidence('stream-error', streamError.message);
+  for (const itemError of codexJsonState?.itemErrors || []) addDiskEvidence('item-error', itemError.message);
+  for (const turnFailure of codexJsonState?.turnFailures || []) addDiskEvidence('turn-failure', turnFailure.message);
+  addDiskEvidence('last-message', lastMessage);
+  addDiskEvidence('result-summary', codexJsonState?.resultSummary);
+  const diskPressureDetected = diskEvidence.length > 0;
+
+  const reasons = [];
+  if (incompleteSession) {
+    reasons.push(`Codex session ended without completing its turn (turn.started=${turnStarted}, turn.completed=${turnCompleted}, turn.failed=${turnFailed}); the process exited 0 but was cut off mid-turn.`);
+    if (diskPressureDetected) {
+      reasons.push(`Disk-exhaustion signals were present in ${diskEvidence.length} location(s) (e.g. "No space left on device") — the likely cause of the interrupted session.`);
+    }
+  }
+
+  return {
+    healthy: !incompleteSession,
+    incompleteSession,
+    diskPressureDetected,
+    diskEvidence,
+    turnStarted,
+    turnCompleted,
+    turnFailed,
+    reasons,
+  };
+};

package/src/codex.lib.mjs

@@ -15,6 +15,10 @@ const os = (await use('os')).default;
 
 // Import log from general lib
 import { log } from './lib.mjs';
+// Issues #1955 / #1990: run-health analysis lives in its own module to keep this
+// file under the max-lines budget. Re-exported below for backward compatibility.
+import { getCodexErrorEventSummary, getCodexCompletionHealth } from './codex-health.lib.mjs';
+export { getCodexErrorEventSummary, getCodexCompletionHealth };
 import { reportError } from './sentry.lib.mjs';
 import { timeouts, retryLimits } from './config.lib.mjs';
 import { detectUsageLimit, formatUsageLimitMessage } from './usage-limit.lib.mjs';
@@ -327,108 +331,6 @@ const upsertCodexItemError = (itemErrors, item) => {
   });
 };
 
-const unwrapCodexErrorMessage = value => {
-  if (!value) return '';
-  if (typeof value !== 'string') {
-    if (typeof value?.error?.message === 'string') return unwrapCodexErrorMessage(value.error.message);
-    if (typeof value?.message === 'string') return unwrapCodexErrorMessage(value.message);
-    return String(value);
-  }
-
-  let text = value.trim();
-  for (let i = 0; i < 3; i++) {
-    if (!text.startsWith('{') && !text.startsWith('[')) break;
-    try {
-      const parsed = JSON.parse(text);
-      if (typeof parsed?.error?.message === 'string') return unwrapCodexErrorMessage(parsed.error.message);
-      if (typeof parsed?.message === 'string') {
-        text = parsed.message.trim();
-        continue;
-      }
-      return JSON.stringify(parsed);
-    } catch {
-      break;
-    }
-  }
-  return text;
-};
-
-const isNonFatalCodexItemErrorMessage = message => /^in-process app-server event stream lagged; dropped \d+ events?$/i.test(message || '');
-
-export const getCodexErrorEventSummary = codexJsonState => {
-  const events = [];
-  const ignoredEvents = [];
-
-  // Issue #1955: When the codex turn genuinely completed (a `turn.completed`
-  // event was observed) and codex never emitted a `turn.failed`, the session
-  // SUCCEEDED. Any stray top-level `error` (stream) or nested item `error` event
-  // in that case is non-fatal and must not fail the run. Two things produce such
-  // strays:
-  //   1. A transient error codex itself retried/recovered from before completing
-  //      the turn (e.g. a momentary stream blip).
-  //   2. Echoed content that merely *looks* like a codex protocol event. The
-  //      codex CLI prints OTEL telemetry (`codex_otel.log_only`,
-  //      event.name="codex.tool_result") containing a raw `Output:` dump of each
-  //      command's stdout. When a command prints a line shaped like a protocol
-  //      event — e.g. a printed NDJSON fixture line
-  //      `{"type":"error","message":"Network lookup skipped in fixture"}` — our
-  //      line-by-line parser misreads it as a genuine codex stream error and
-  //      fails an otherwise-successful run. This was the exact false positive in
-  //      issue #1955 (codex finished, working tree clean, CI passed, yet the run
-  //      was reported failed).
-  // `turn.failed` is the authoritative failure signal, so it is NEVER suppressed
-  // here; only non-`turn` error events are gated on turn completion.
-  const turnCompleted = (codexJsonState?.eventCounts?.['turn.completed'] || 0) > 0;
-  const turnFailed = (codexJsonState?.turnFailures?.length || 0) > 0;
-  const sessionSucceeded = turnCompleted && !turnFailed;
-
-  const addEvents = (type, items = []) => {
-    for (const item of items) {
-      const message = unwrapCodexErrorMessage(item?.message);
-      const event = { type, message: message || 'Codex emitted an error event' };
-      if (type === 'item' && isNonFatalCodexItemErrorMessage(message)) {
-        ignoredEvents.push({
-          ...event,
-          reason: 'Codex app-server backpressure warning; the turn can still complete successfully',
-        });
-        continue;
-      }
-      if (type !== 'turn' && sessionSucceeded) {
-        ignoredEvents.push({
-          ...event,
-          reason: 'Codex turn completed successfully with no turn.failed; stray non-turn error event is non-fatal (Issue #1955)',
-        });
-        continue;
-      }
-      events.push(event);
-    }
-  };
-
-  addEvents('item', codexJsonState?.itemErrors);
-  addEvents('turn', codexJsonState?.turnFailures);
-  addEvents('stream', codexJsonState?.streamErrors);
-
-  const countByType = items => ({
-    item: items.filter(item => item.type === 'item').length,
-    turn: items.filter(item => item.type === 'turn').length,
-    stream: items.filter(item => item.type === 'stream').length,
-  });
-
-  return {
-    hasError: events.length > 0,
-    message: events[0]?.message || null,
-    events,
-    ignoredEvents,
-    counts: countByType(events),
-    ignoredCounts: countByType(ignoredEvents),
-    observedCounts: {
-      item: codexJsonState?.itemErrors?.length || 0,
-      turn: codexJsonState?.turnFailures?.length || 0,
-      stream: codexJsonState?.streamErrors?.length || 0,
-    },
-  };
-};
-
 export const parseCodexExecJsonOutput = (output, state = {}, requestedModelId = null) => {
   const nextState = {
     sessionId: state.sessionId || null,
@@ -1339,6 +1241,59 @@ export const executeCodexCommand = async params => {
         };
       }
 
+      // Issue #1990: exit code 0 and the absence of a fatal codex error event are
+      // necessary but NOT sufficient for success. Verify the run actually
+      // completed its turn before declaring success. A broken-but-exit-0 run (the
+      // codex process cut off mid-turn by disk exhaustion / OOM) previously
+      // reported SUCCESS, which under docker isolation also discarded the
+      // container filesystem needed to inspect and retry the failure (#1990).
+      const completionHealth = getCodexCompletionHealth(codexJsonState, { lastMessage });
+      if (!completionHealth.healthy) {
+        await log('\n\n❌ Codex exited 0 but the run did not complete — treating as failure', { level: 'error' });
+        for (const reason of completionHealth.reasons) {
+          await log(`   • ${reason}`, { level: 'error' });
+        }
+        await log(`   📊 turn.started=${completionHealth.turnStarted}, turn.completed=${completionHealth.turnCompleted}, turn.failed=${completionHealth.turnFailed}`, { verbose: true });
+        if (completionHealth.diskPressureDetected) {
+          await log('   💽 Disk-exhaustion evidence (diagnostic):', { level: 'error' });
+          for (const evidence of completionHealth.diskEvidence.slice(0, 5)) {
+            await log(`      ↳ [${evidence.source}] ${evidence.text}`, { level: 'error' });
+          }
+          await log('   💡 Free disk space before retrying. Under docker isolation the container is preserved on failure for inspection.', { level: 'error' });
+        }
+
+        const resourcesAfter = await getResourceSnapshot();
+        await log('\n📈 System resources after execution:', { verbose: true });
+        await log(`   Memory: ${resourcesAfter.memory.split('\n')[1]}`, { verbose: true });
+        await log(`   Load: ${resourcesAfter.load}`, { verbose: true });
+
+        // Issue #1990: preserve the codex session so an outer full restart can
+        // resume with context (mirrors the transient-error retry above and the
+        // `--tool claude` behavior). We do NOT inline-retry within the same broken
+        // container — the run is registered as a failure so the session and (under
+        // docker isolation) the container filesystem are preserved for a clean
+        // restart at the orchestration level.
+        if (sessionId && !argv.resume) argv.resume = sessionId;
+
+        return {
+          success: false,
+          sessionId,
+          limitReached,
+          limitResetTime,
+          pricingInfo,
+          publicPricingEstimate: pricingInfo?.totalCostUSD ?? null,
+          resultModelUsage,
+          subAgentCalls: codexJsonState.subAgentCalls.length > 0 ? codexJsonState.subAgentCalls : null,
+          codexJsonDetails: codexJsonState,
+          errorInfo: getCodexErrorEventSummary(codexJsonState),
+          completionHealth,
+          incompleteSession: completionHealth.incompleteSession,
+          diskPressureDetected: completionHealth.diskPressureDetected,
+          result: completionHealth.reasons.join(' '),
+          resultSummary: lastTextContent || null,
+        };
+      }
+
       await log('\n\n✅ Codex command completed');
 
       // Issue #1263: Log if result summary was captured

package/src/gemini.lib.mjs

@@ -21,6 +21,7 @@ import { defaultModels, geminiModels } from './models/index.mjs';
 import { checkPlaywrightMcpPackageAvailability } from './playwright-mcp.lib.mjs';
 import { classifyRetryableError, getRetryDelayMs, maybeSwitchToFallbackModel, waitWithCountdown } from './tool-retry.lib.mjs';
 import { getCumulativeContextInputTokens, toTokenCount } from './context-fill.lib.mjs';
+import { getTerminalEventCompletionHealth } from './tool-run-health.lib.mjs'; // Issue #1990
 
 const shellQuote = value => `"${String(value).replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"`;
 
@@ -581,6 +582,52 @@ export const executeGeminiCommand = async params => {
         };
       }
 
+      // Issue #1990: exit 0 and a non-empty stream are necessary but NOT
+      // sufficient. gemini-cli's stream-json ends with a terminal `result` event;
+      // a run that did work but never emitted it was cut off mid-run (e.g. the
+      // docker container ran out of disk) and must be registered as a failure so
+      // the session is preserved for a context-preserving restart and — under
+      // docker isolation — the container filesystem is kept for inspection.
+      const completionHealth = getTerminalEventCompletionHealth({
+        eventCounts: geminiJsonState.eventCounts,
+        terminalEventTypes: ['result'],
+        hadActivity: (geminiJsonState.messageCount || 0) > 0 || (geminiJsonState.toolUseCount || 0) > 0,
+        diskEvidenceTexts: [
+          { source: 'output', text: allOutput },
+          { source: 'result-summary', text: geminiJsonState.resultSummary },
+        ],
+      });
+      if (!completionHealth.healthy) {
+        await log('\n\n❌ Gemini exited 0 but the run did not complete — treating as failure', { level: 'error' });
+        for (const reason of completionHealth.reasons) {
+          await log(`   • ${reason}`, { level: 'error' });
+        }
+        if (completionHealth.diskPressureDetected) {
+          await log('   💽 Disk-exhaustion evidence (diagnostic):', { level: 'error' });
+          for (const evidence of completionHealth.diskEvidence.slice(0, 5)) {
+            await log(`      ↳ [${evidence.source}] ${evidence.text}`, { level: 'error' });
+          }
+          await log('   💡 Free disk space before retrying. Under docker isolation the container is preserved on failure for inspection.', { level: 'error' });
+        }
+        if (sessionId && !argv.resume) argv.resume = sessionId;
+        return {
+          success: false,
+          sessionId,
+          limitReached,
+          limitResetTime,
+          messageCount: geminiJsonState.messageCount || 0,
+          toolUseCount: geminiJsonState.toolUseCount || 0,
+          resultModelUsage: geminiJsonState.resultModelUsage || buildGeminiResultModelUsage(mappedModel),
+          pricingInfo: { modelId: mappedModel, modelName: mappedModel, provider: 'Google', totalCostUSD: null },
+          publicPricingEstimate: null,
+          resultSummary: geminiJsonState.resultSummary || null,
+          completionHealth,
+          incompleteSession: completionHealth.incompleteSession,
+          diskPressureDetected: completionHealth.diskPressureDetected,
+          errorInfo: { message: completionHealth.reasons.join(' ') },
+        };
+      }
+
       await log('\n\n✅ Gemini command completed');
       await log(`📊 Total messages: ${geminiJsonState.messageCount || 0}, Tool uses: ${geminiJsonState.toolUseCount || 0}`);
       if (geminiJsonState.resultSummary) {

package/src/git.lib.mjs

@@ -233,7 +233,7 @@ export const validateGitIdentity = async ($, options = {}) => {
   const { log = console.log } = options;
 
   // Check user.name
-  let userName = null;
+  let userName;
   try {
     const nameResult = await $`git config user.name 2>/dev/null || true`;
     userName = nameResult.stdout.toString().trim() || null;
@@ -242,7 +242,7 @@ export const validateGitIdentity = async ($, options = {}) => {
   }
 
   // Check user.email
-  let userEmail = null;
+  let userEmail;
   try {
     const emailResult = await $`git config user.email 2>/dev/null || true`;
     userEmail = emailResult.stdout.toString().trim() || null;

package/src/github-repository-names.lib.mjs

@@ -19,7 +19,7 @@ function normalizeRepositoryFullName(owner, repositoryName) {
 
 function parseGitHubRepositoryUrlToken(token) {
   const cleaned = trimOutputToken(token);
-  let pathName = null;
+  let pathName;
 
   if (cleaned.startsWith('git@github.com:')) {
     pathName = cleaned.slice('git@github.com:'.length);

package/src/github.lib.mjs

@@ -967,7 +967,7 @@ export async function fetchProjectIssues(projectNumber, owner, statusFilter) {
         context: 'github.lib.mjs - GitHub CLI auth status check',
         level: 'error',
       });
-      throw new Error('GitHub CLI authentication failed. Please run: gh auth login');
+      throw new Error('GitHub CLI authentication failed. Please run: gh auth login', { cause: error });
     }
     // Add delay to respect rate limits
     await log('   ⏰ Waiting 2 seconds before API call to respect rate limits...', { verbose: true });

package/src/handoff-skill.lib.mjs

@@ -116,7 +116,7 @@ const updateGitExclude = async ({ $, tempDir, log }) => {
     return false;
   }
 
-  let existing = '';
+  let existing;
   try {
     existing = await fs.readFile(excludePath, 'utf8');
   } catch {

package/src/hive-screens.lib.mjs

@@ -135,7 +135,7 @@ export const parseHiveScreensArgs = argv => {
  * the typical `NNNNN.name` session names.
  */
 export const listDetachedSessions = async ({ exec = execAsync } = {}) => {
-  let stdout = '';
+  let stdout;
   try {
     ({ stdout } = await exec('screen -ls'));
   } catch (err) {

package/src/i18n.lib.mjs

@@ -75,7 +75,7 @@ function refreshI18nRuntime() {
 export async function loadTranslations(locale) {
   if (localeCache.has(locale)) return localeCache.get(locale);
 
-  let translations = {};
+  let translations;
   try {
     translations = await readLocaleFile(locale);
   } catch {

package/src/instrument.mjs

@@ -42,7 +42,7 @@ const shouldDisableSentry = () => {
 // Lazily import Sentry only if needed
 // This prevents the Sentry packages from keeping the event loop alive when not needed
 let Sentry = null;
-let nodeProfilingIntegration = null;
+let nodeProfilingIntegration;
 
 // Initialize Sentry if not disabled
 if (!shouldDisableSentry()) {

package/src/interactive-mode.lib.mjs

@@ -151,14 +151,14 @@ export const createInteractiveHandler = options => {
       }
     }
 
-    let hits = [];
+    let hits;
     try {
       hits = await containsKnownToken(body, knownTokens);
     } catch {
       hits = [];
     }
 
-    let sanitized = body;
+    let sanitized;
     try {
       sanitized = await sanitizeCommentBody(body, {
         knownTokens,
@@ -495,7 +495,7 @@ ${createRawJsonSection(data)}`;
     state.toolUseRegistry.set(toolId, { toolName, toolIcon });
 
     // Format tool input based on tool type
-    let inputDisplay = '';
+    let inputDisplay;
     const input = toolUse.input || {};
 
     if (toolName === 'Bash' && input.command) {

package/src/isolation-runner.lib.mjs

@@ -1266,7 +1266,7 @@ export async function ensureHostGitIdentityForIsolation(options = {}) {
       const gitLib = await import('./git.lib.mjs');
       return gitLib.repairGitIdentity();
     });
-  let repairOutcome = null;
+  let repairOutcome;
   try {
     repairOutcome = await repairFn();
   } catch (error) {

package/src/qwen.lib.mjs

@@ -22,6 +22,7 @@ import { qwenModels, defaultModels } from './models/index.mjs';
 import { checkPlaywrightMcpPackageAvailability } from './playwright-mcp.lib.mjs';
 import { classifyRetryableError, getRetryDelayMs, maybeSwitchToFallbackModel, waitWithCountdown } from './tool-retry.lib.mjs';
 import { getCumulativeContextInputTokens, getRestoredContextInputTokens, toTokenCount } from './context-fill.lib.mjs';
+import { getTerminalEventCompletionHealth } from './tool-run-health.lib.mjs'; // Issue #1990
 
 export const mapModelToId = model => qwenModels[model] || model;
 
@@ -638,6 +639,48 @@ export const executeQwenCommand = async params => {
         };
       }
 
+      // Issue #1990: exit 0 with no error event is necessary but NOT sufficient.
+      // qwen-code's stream-json ends with a terminal `result` event; a run that
+      // did work but never emitted it was cut off mid-run (e.g. the docker
+      // container ran out of disk) and must be registered as a failure so the
+      // session is preserved for a context-preserving restart and — under docker
+      // isolation — the container filesystem is kept for inspection.
+      const completionHealth = getTerminalEventCompletionHealth({
+        eventCounts: qwenState.eventCounts,
+        terminalEventTypes: ['result'],
+        hadActivity: (qwenState.parsedEvents?.length || 0) > 0,
+        diskEvidenceTexts: [
+          { source: 'output', text: allOutput },
+          { source: 'result-summary', text: resultSummary },
+        ],
+      });
+      if (!completionHealth.healthy) {
+        await log('\n\n❌ Qwen Code exited 0 but the run did not complete — treating as failure', { level: 'error' });
+        for (const reason of completionHealth.reasons) {
+          await log(`   • ${reason}`, { level: 'error' });
+        }
+        if (completionHealth.diskPressureDetected) {
+          await log('   💽 Disk-exhaustion evidence (diagnostic):', { level: 'error' });
+          for (const evidence of completionHealth.diskEvidence.slice(0, 5)) {
+            await log(`      ↳ [${evidence.source}] ${evidence.text}`, { level: 'error' });
+          }
+          await log('   💡 Free disk space before retrying. Under docker isolation the container is preserved on failure for inspection.', { level: 'error' });
+        }
+        if (sessionId && !argv.resume) argv.resume = sessionId;
+        return {
+          success: false,
+          sessionId,
+          limitReached: false,
+          limitResetTime: null,
+          ...usageResult,
+          resultSummary,
+          completionHealth,
+          incompleteSession: completionHealth.incompleteSession,
+          diskPressureDetected: completionHealth.diskPressureDetected,
+          errorInfo: { message: completionHealth.reasons.join(' ') },
+        };
+      }
+
       await log('\n\n✅ Qwen Code command completed');
       if (resultSummary) {
         await log('📝 Captured result summary from Qwen Code output', { verbose: true });

package/src/session-monitor.lib.mjs

@@ -1025,7 +1025,7 @@ export async function resumeTrackedSessions(options = {}) {
     return { resumed, skipped };
   }
 
-  let persisted = [];
+  let persisted;
   try {
     persisted = store.load();
   } catch (error) {
@@ -1297,7 +1297,7 @@ export async function getRunningSessionItems(verbose = false, options = {}) {
   const screenChecker = options.screenChecker || checkScreenSessionExists;
 
   for (const [sessionName, sessionInfo] of activeSessions.entries()) {
-    let running = false;
+    let running;
     let status = null;
 
     if (sessionInfo.isolationBackend) {

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

@@ -1275,9 +1275,9 @@ ${prBody}`,
           }
 
           if (errorMsg.includes('No commits between') || errorMsg.includes("Head sha can't be blank")) {
-            throw new Error(`PR creation failed - no commits between branches: ${cleanError}`);
+            throw new Error(`PR creation failed - no commits between branches: ${cleanError}`, { cause: prCreateError });
           } else {
-            throw new Error(`PR creation failed: ${cleanError}`);
+            throw new Error(`PR creation failed: ${cleanError}`, { cause: prCreateError });
           }
         }
       }

package/src/solve.escalate.lib.mjs

@@ -125,9 +125,6 @@ export const parseEscalateRange = value => {
     throw new Error(`Invalid --escalate value: ${JSON.stringify(value)}. Expected a model range like "sonnet-fable".`);
   }
   const trimmed = raw.trim().toLowerCase();
-  if (trimmed === '') {
-    raw = DEFAULT_ESCALATE_RANGE;
-  }
   const parts = (trimmed === '' ? DEFAULT_ESCALATE_RANGE : trimmed).split('-');
 
   const order = MODEL_ESCALATION_ORDER;

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

@@ -159,7 +159,7 @@ export const runKeepWorkingUntilDone = async ({ issueUrl, owner, repo, issueNumb
   let iteration = 0;
   while (true) {
     // Gather and scan sources fresh on every iteration.
-    let sources = [];
+    let sources;
     try {
       sources = await collectDeferredWorkSources({ owner, repo, prNumber, resultSummary: lastResultSummary });
     } catch (error) {

package/src/solve.repository.lib.mjs

@@ -550,8 +550,8 @@ export const setupRepository = async (argv, owner, repo, forkOwner = null, issue
         }
         if (!safeToDelete) {
           if (argv.allowForceNonForkRepositoryDeletion) {
+            // Force flag set — proceed with deletion despite the failed safety check.
             await log(`${formatAligned('⚠️', 'Force deletion ENABLED:', '--allow-force-non-fork-repository-deletion — proceeding despite potential data loss')}`, { level: 'warning' });
-            safeToDelete = true;
           } else {
             await log(`  💡 Manual fix required: back up work, then: gh repo delete ${existingForkName} --yes`);
             await log(`     Then run this command again to create a proper fork of ${owner}/${repo}`);

package/src/solve.validation.lib.mjs

@@ -302,7 +302,7 @@ export const performSystemChecks = async (minDiskSpace = 10240, skipToolConnecti
 
   // Skip tool connection validation if in dry-run mode or explicitly requested
   if (!skipToolConnection) {
-    let isToolConnected = false;
+    let isToolConnected;
     if (argv.useAgentCommander) {
       const agentCommanderLib = await import('./agent-commander.lib.mjs');
       isToolConnected = await agentCommanderLib.validateAgentCommanderConnection({
@@ -361,7 +361,6 @@ export const performSystemChecks = async (minDiskSpace = 10240, skipToolConnecti
         await log('❌ Cannot proceed without Claude CLI connection', { level: 'error' });
         return false;
       }
-      isToolConnected = true;
     }
 
     // Check GitHub permissions (only when tool check is not skipped)

package/src/telegram-bot-launcher.lib.mjs

@@ -194,13 +194,9 @@ export async function launchBotWithRetry(bot, launchOptions, retryOptions = {})
             reject(new Error('Bot launch aborted during retry wait'));
             return;
           }
+          // `{ once: true }` removes the abort listener after it fires; on the
+          // natural-timeout path it is released when the AbortSignal is collected.
           signal.addEventListener('abort', onAbort, { once: true });
-          // Clean up the listener when the timer fires naturally
-          const originalResolve = resolve;
-          resolve = () => {
-            signal.removeEventListener('abort', onAbort);
-            originalResolve();
-          };
         }
       });
     }

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

@@ -116,7 +116,7 @@ export const registerTokensCommand = (bot, options = {}) => {
 
     // Step 2: authenticate by ownership of an allowlisted chat.
     const allowedChatIds = resolveAllowedChatIds(allowedChats);
-    let isOperator = false;
+    let isOperator;
     try {
       isOperator = await isOperatorOfAnyAllowedChat({
         telegram: ctx.telegram,

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

@@ -145,7 +145,7 @@ export function registerTopCommand(bot, options) {
     const screenName = `top-chat-${chatId}`;
 
     // Check if screen session already exists
-    let sessionExists = false;
+    let sessionExists;
     try {
       const { stdout } = await exec('screen -ls');
       sessionExists = stdout.includes(screenName);

package/src/tool-run-health.lib.mjs

@@ -0,0 +1,64 @@
+// Tool-agnostic run-health analysis (Issue #1990).
+//
+// Background: under docker isolation two long-running `solve --tool codex` tasks
+// reported SUCCESS (Exit Code: 0) while their containers had run out of disk —
+// the AI session was cut off mid-run, no commits were produced, yet the process
+// exited 0. Reporting that as success also discarded the container filesystem we
+// needed to inspect and retry from.
+//
+// codex.lib.mjs gets a bespoke gate (paired turn.started/turn.completed lifecycle
+// — see codex-health.lib.mjs) and claude.lib.mjs already requires its final
+// `result` event (shouldFailClaudeStreamWithoutResult). This module provides the
+// equivalent gate for the tools whose stream-json output (adopted from the Claude
+// Agent SDK schema) ends with a single terminal `result` event: gemini-cli and
+// qwen-code. An exit-0 run that clearly began work but never emitted that
+// terminal event was interrupted and must NOT be reported as success.
+//
+// opencode is deliberately NOT gated here. Its `run --format json` output has no
+// single terminal completion event we have verified is always emitted before a
+// clean exit — opencode.lib.mjs treats several event types ('text', 'assistant',
+// 'message', 'result', 'step_finish') as best-effort and decides success purely
+// on the exit code. Gating opencode on a terminal event without first confirming
+// upstream that it is reliably flushed would risk converting genuine successes
+// into failures, so it is left as follow-up. See docs/case-studies/issue-1990.
+//
+// Disk-exhaustion strings ("No space left on device", ENOSPC) are surfaced only
+// as supporting *diagnostics* — never an independent failure gate — to avoid the
+// issue #1955 class of false positive where a tool echoes a command's stdout that
+// merely mentions the phrase.
+
+import { isENOSPC } from './lib.mjs';
+
+export const getTerminalEventCompletionHealth = ({ eventCounts = {}, terminalEventTypes = ['result'], hadActivity = false, diskEvidenceTexts = [] } = {}) => {
+  const terminalCount = terminalEventTypes.reduce((sum, type) => sum + (eventCounts[type] || 0), 0);
+
+  // Only flag a run that did work but never reached its terminal event. A run
+  // with no activity at all is handled separately by each tool (e.g. gemini's
+  // emittedNoEvents check) and must not be double-counted here.
+  const incompleteSession = hadActivity && terminalCount === 0;
+
+  const diskEvidence = [];
+  for (const { source, text } of diskEvidenceTexts) {
+    if (text && isENOSPC(text)) {
+      diskEvidence.push({ source, text: String(text).replace(/\s+/g, ' ').trim().slice(0, 300) });
+    }
+  }
+  const diskPressureDetected = diskEvidence.length > 0;
+
+  const reasons = [];
+  if (incompleteSession) {
+    reasons.push(`The tool exited 0 but never emitted its terminal completion event (${terminalEventTypes.join('/')}); the session was cut off mid-run.`);
+    if (diskPressureDetected) {
+      reasons.push(`Disk-exhaustion signals were present in ${diskEvidence.length} location(s) (e.g. "No space left on device") — the likely cause of the interrupted session.`);
+    }
+  }
+
+  return {
+    healthy: !incompleteSession,
+    incompleteSession,
+    diskPressureDetected,
+    diskEvidence,
+    terminalCount,
+    reasons,
+  };
+};

package/src/use-m-bootstrap.lib.mjs

@@ -24,7 +24,7 @@ export const fetchUseMCodeFromCdn = async ({ fetcher = fetch } = {}) => {
   try {
     return await fetchUseMCodeFromUrl(USE_M_BOOTSTRAP_FALLBACK_URL, fetcher);
   } catch (fallbackError) {
-    throw new Error(`Failed to load use-m bootstrap from primary and fallback URLs: ${primaryError.message}; ${fallbackError.message}`);
+    throw new Error(`Failed to load use-m bootstrap from primary and fallback URLs: ${primaryError.message}; ${fallbackError.message}`, { cause: fallbackError });
   }
 };
 

package/src/useless-tools.lib.mjs

@@ -154,7 +154,7 @@ export const resolveClaudeSessionToolFlags = async ({ argv, log, fallbackBuildMc
 export const ensureDisallowedToolsInSettings = async ({ settingsPath, log } = {}) => {
   const resolvedPath = settingsPath || path.join(os.homedir(), '.claude', 'settings.json');
   const toBlock = buildDisallowedToolsList();
-  let settings = {};
+  let settings;
   try {
     const content = await fs.readFile(resolvedPath, 'utf-8');
     settings = JSON.parse(content);

package/src/youtrack/solve.youtrack.lib.mjs

@@ -15,8 +15,8 @@ const { parseYouTrackIssueId, updateYouTrackIssueStage, addYouTrackComment, crea
  * @returns {Object} Validation result with YouTrack info
  */
 export async function validateYouTrackUrl(issueUrl) {
-  let isYouTrackUrl = null;
-  let youTrackIssueId = null;
+  let isYouTrackUrl;
+  let youTrackIssueId;
   let youTrackConfig = null;
 
   if (!issueUrl) {

package/src/youtrack/youtrack.lib.mjs

@@ -128,7 +128,7 @@ async function makeYouTrackRequest(endpoint, config, options = {}) {
     return await response.json();
   } catch (error) {
     if (error.message.includes('fetch')) {
-      throw new Error(`Failed to connect to YouTrack at ${config.url}: ${error.message}`);
+      throw new Error(`Failed to connect to YouTrack at ${config.url}: ${error.message}`, { cause: error });
     }
     throw error;
   }