@link-assistant/hive-mind 2.0.23 → 2.0.25

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

@@ -58,6 +58,11 @@ const DOCKER_ISOLATION_SHELL = 'sh';
 // less headroom than this cannot safely pull one. Diagnostic only — never
 // blocks startup. See issue #1914.
 const DOCKER_ISOLATION_LOW_DISK_GIB = 40;
+// Docker-only start gate used to capture the container writable-layer baseline
+// before the task command begins cloning or generating files. The parent
+// releases the gate immediately after `docker inspect --size`; the fallback
+// keeps the task from hanging forever if the parent exits at the wrong time.
+const DOCKER_START_GATE_WAIT_TENTHS = 300;
 // Sentinel start-command's detached docker logger records when it cannot capture
 // the container's real exit code. A terminal `$ --status` carrying this value is
 // ambiguous — the container may still be running — so we cross-check it against
@@ -94,6 +99,16 @@ function buildShellCommand(command, args = []) {
   return [command, ...args].map(shellQuote).join(' ');
 }
 
+function buildDockerStartGatePath(sessionId) {
+  return sessionId ? `/tmp/hive-mind-disk-baseline-${sessionId}` : null;
+}
+
+function buildDockerStartGatedCommand(taskCommand, sessionId) {
+  const gatePath = buildDockerStartGatePath(sessionId);
+  if (!gatePath) return taskCommand;
+  return `gate=${shellQuote(gatePath)}; i=0; while [ ! -e "$gate" ] && [ "$i" -lt ${DOCKER_START_GATE_WAIT_TENTHS} ]; do i=$((i+1)); sleep 0.1; done; rm -f "$gate"; exec ${taskCommand}`;
+}
+
 function shouldRunPrivilegedDockerIsolation(image, env = process.env) {
   return String(env.HIVE_MIND_IMAGE_VARIANT || '').toLowerCase() === 'dind' || String(image || '').includes('hive-mind-dind');
 }
@@ -234,7 +249,8 @@ export function buildDockerIsolationStartArgs(command, args = [], options = {})
     startArgs.push('--volume', `${mount.source}:${mount.target}`);
   }
 
-  startArgs.push('--detached', '--session', sessionId, '--', buildShellCommand(command, args));
+  const taskCommand = buildShellCommand(command, args);
+  startArgs.push('--detached', '--session', sessionId, '--', buildDockerStartGatedCommand(taskCommand, sessionId));
   return startArgs;
 }
 
@@ -541,7 +557,7 @@ async function logDockerIsolationPostLaunchDiagnostics(sessionId, env = process.
  * @param {string} [options.sessionId] - UUID for session tracking (auto-generated if not provided)
  * @param {string} [options.tool] - AI tool selected for the task; used to scope Docker auth mounts
  * @param {boolean} [options.verbose] - Enable verbose logging
- * @returns {Promise<{success: boolean, sessionId: string, output: string, error?: string, warning?: string}>}
+ * @returns {Promise<{success: boolean, sessionId: string, output: string, error?: string, warning?: string, containerFilesystemStartBytes?: number|null}>}
  */
 export async function executeWithIsolation(command, args, options = {}) {
   const { backend, verbose = false } = options;
@@ -598,6 +614,15 @@ export async function executeWithIsolation(command, args, options = {}) {
     if (result.error) stream(`[VERBOSE] isolation-runner: Error: ${result.error}`);
   }
 
+  let containerFilesystemStartBytes = null;
+  if (result.success && backend === 'docker') {
+    try {
+      containerFilesystemStartBytes = await getDockerContainerWritableLayerSize(sessionId, verbose);
+    } finally {
+      await releaseDockerContainerStartGate(sessionId, verbose);
+    }
+  }
+
   // Issue #1939: capture the freshly-launched docker session's reported status
   // and the live container state together, so the next iteration has the data to
   // diagnose a premature "executed/-1" status (problem #1) or a surprise image
@@ -611,6 +636,7 @@ export async function executeWithIsolation(command, args, options = {}) {
       success: true,
       sessionId,
       output: result.output,
+      containerFilesystemStartBytes,
     };
   }
 
@@ -831,6 +857,77 @@ export async function checkDockerContainerRunning(containerName, verbose = false
   }
 }
 
+export function parseDockerContainerWritableLayerSizeOutput(output) {
+  const text = String(output || '').trim();
+  if (!text) return null;
+  const bytes = Number.parseInt(text.split(/\s+/)[0], 10);
+  return Number.isFinite(bytes) && bytes >= 0 ? bytes : null;
+}
+
+/**
+ * Best-effort size of a Docker task container's writable layer.
+ *
+ * `docker inspect --size` exposes `.SizeRw`, which excludes the image's base
+ * layers and counts only filesystem data created or changed by this container.
+ * That is the closest Docker-native representation of per-task disk usage.
+ *
+ * @param {string} containerName - Container name (the session UUID)
+ * @param {boolean} [verbose] - Enable verbose logging
+ * @returns {Promise<number|null>} Writable layer bytes, or null when unavailable.
+ */
+export async function getDockerContainerWritableLayerSize(containerName, verbose = false) {
+  if (!containerName) return null;
+  try {
+    const result = await $({ mirror: false })`docker inspect --size -f ${'{{.SizeRw}}'} ${containerName}`;
+    const bytes = parseDockerContainerWritableLayerSizeOutput(result.stdout?.toString() || '');
+    if (verbose) {
+      const label = bytes === null ? 'unknown' : `${bytes} bytes`;
+      console.log(`[VERBOSE] isolation-runner: docker writable layer size for '${containerName}': ${label}`);
+    }
+    return bytes;
+  } catch (error) {
+    if (verbose) {
+      const stderr = error?.stderr?.toString?.().trim();
+      console.log(`[VERBOSE] isolation-runner: could not inspect writable layer size for '${containerName}': ${stderr || error?.message || error}`);
+    }
+    return null;
+  }
+}
+
+/**
+ * Release the Docker-only start gate after the writable-layer baseline has been
+ * captured. Best-effort: the gated task also has a timeout fallback.
+ *
+ * @param {string} containerName - Container name (the session UUID)
+ * @param {boolean} [verbose] - Enable verbose logging
+ * @returns {Promise<boolean>} true when the gate file was touched.
+ */
+export async function releaseDockerContainerStartGate(containerName, verbose = false) {
+  const gatePath = buildDockerStartGatePath(containerName);
+  if (!containerName || !gatePath) return false;
+  const releaseCommand = `touch ${shellQuote(gatePath)}`;
+  let lastError = null;
+
+  for (let attempt = 1; attempt <= 5; attempt++) {
+    try {
+      await $({ mirror: false })`docker exec ${containerName} sh -c ${releaseCommand}`;
+      if (verbose) {
+        console.log(`[VERBOSE] isolation-runner: released docker start gate for '${containerName}'`);
+      }
+      return true;
+    } catch (error) {
+      lastError = error;
+      await new Promise(resolve => setTimeout(resolve, 200));
+    }
+  }
+
+  if (verbose) {
+    const stderr = lastError?.stderr?.toString?.().trim();
+    console.log(`[VERBOSE] isolation-runner: could not release docker start gate for '${containerName}': ${stderr || lastError?.message || lastError}`);
+  }
+  return false;
+}
+
 /**
  * Best-effort removal for a Docker container backing a native
  * `$ --isolated docker` session.
@@ -1169,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

@@ -338,19 +338,32 @@ async function resolvePullRequestUrlFromSessionLog(logPath, ctx, { verbose = fal
 }
 
 /**
- * Issue #1945: Parse `📊 [DISK]` checkpoint markers out of the captured solve
- * log and, when the captured sizes cross the 5 GB threshold(s), build a
- * Telegram extraSection that warns the operator. Returns an empty string if
- * the log is unreadable or contains no markers.
+ * Issue #1945/#1988: Parse `📊 [DISK]` repository-size checkpoint markers out
+ * of the captured solve log, optionally add docker writable-layer sizes, and
+ * build the Telegram extraSection. Returns an empty string if there is no
+ * repository or docker filesystem data to show.
  */
-async function buildDiskDiagnosticsExtraSection(logPath, { verbose = false, readFile = fs.readFile } = {}) {
-  if (!logPath) return '';
+async function buildDiskDiagnosticsExtraSection(logPath, { verbose = false, readFile = fs.readFile, isolationBackend = null, containerFilesystemStartBytes = null, containerFilesystemAfterBytes = null } = {}) {
+  if (!logPath && !Number.isFinite(containerFilesystemStartBytes) && !Number.isFinite(containerFilesystemAfterBytes)) return '';
   try {
     const diskLib = await import('./solve.disk-diagnostics.lib.mjs');
-    const logText = await readFile(logPath, 'utf8');
+    let logText = '';
+    if (logPath) {
+      try {
+        logText = await readFile(logPath, 'utf8');
+      } catch (readError) {
+        if (verbose) {
+          console.log(`[VERBOSE] Could not read session log ${logPath} for disk diagnostics: ${readError?.message || readError}`);
+        }
+      }
+    }
     const parsed = diskLib.parseDiskMarkers(logText);
-    if (!parsed.afterClone && !parsed.afterAgent) return '';
-    return diskLib.formatDiskDiagnosticsBlock(parsed);
+    if (!parsed.afterClone && !parsed.afterAgent && !Number.isFinite(containerFilesystemStartBytes) && !Number.isFinite(containerFilesystemAfterBytes)) return '';
+    return diskLib.formatDiskDiagnosticsBlock(parsed, {
+      isolationBackend,
+      containerFilesystemStartBytes,
+      containerFilesystemAfterBytes,
+    });
   } catch (error) {
     if (verbose) {
       console.log(`[VERBOSE] Could not inspect session log ${logPath} for disk diagnostics: ${error?.message || error}`);
@@ -359,6 +372,26 @@ async function buildDiskDiagnosticsExtraSection(logPath, { verbose = false, read
   }
 }
 
+async function getDockerContainerFilesystemSizeForSession(sessionName, sessionInfo, { verbose = false, sizeProvider = null } = {}) {
+  if (sessionInfo?.isolationBackend !== 'docker') return null;
+  const containerName = sessionInfo.sessionId || sessionName;
+  if (!containerName) return null;
+  try {
+    if (typeof sizeProvider === 'function') {
+      const bytes = await sizeProvider(containerName, { sessionName, sessionInfo, verbose });
+      return Number.isFinite(bytes) ? bytes : null;
+    }
+    const runner = await getIsolationRunner();
+    if (typeof runner.getDockerContainerWritableLayerSize !== 'function') return null;
+    return await runner.getDockerContainerWritableLayerSize(containerName, verbose);
+  } catch (error) {
+    if (verbose) {
+      console.log(`[VERBOSE] Could not inspect docker filesystem size for ${containerName}: ${error?.message || error}`);
+    }
+    return null;
+  }
+}
+
 function isSuccessfulTaskCompletion({ exitCode = null, status = null } = {}) {
   const outcome = classifySessionOutcome({ exitCode, status });
   if (outcome.failed) return false;
@@ -783,13 +816,22 @@ export async function monitorSessions(bot, verbose = false, options = {}) {
           }
         }
 
-        // Issue #1945: append a "💾 Disk usage" block (with warnings when the
-        // cloned repo, the delta during the run, or the total exceed 5 GB)
-        // parsed from the captured solve log markers.
+        // Issue #1945/#1988: append a "💾 Disk usage" block from repository
+        // size markers and, for docker isolation, the container writable layer.
         const diskExtraSections = [];
         try {
           const diskLogPath = statusResult?.logPath || sessionInfo?.logPath || null;
-          const diskBlock = await buildDiskDiagnosticsExtraSection(diskLogPath, { verbose });
+          const containerFilesystemAfterBytes = await getDockerContainerFilesystemSizeForSession(sessionName, sessionInfo, {
+            verbose,
+            sizeProvider: options.dockerContainerSizeProvider,
+          });
+          const diskBlock = await buildDiskDiagnosticsExtraSection(diskLogPath, {
+            verbose,
+            readFile: options.readFile,
+            isolationBackend: sessionInfo?.isolationBackend || statusResult?.isolation || null,
+            containerFilesystemStartBytes: Number.isFinite(sessionInfo?.containerFilesystemStartBytes) ? sessionInfo.containerFilesystemStartBytes : null,
+            containerFilesystemAfterBytes,
+          });
           if (diskBlock) diskExtraSections.push(diskBlock);
         } catch (diskError) {
           if (verbose) {
@@ -983,7 +1025,7 @@ export async function resumeTrackedSessions(options = {}) {
     return { resumed, skipped };
   }
 
-  let persisted = [];
+  let persisted;
   try {
     persisted = store.load();
   } catch (error) {
@@ -1255,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/session-store.lib.mjs

@@ -33,7 +33,7 @@ import path from 'node:path';
 // excluded so the snapshot stays small and safe to reload.
 // `args` (#1927 review follow-up) is persisted so a killed /solve can be resumed
 // with its exact original invocation plus `--resume <lastSessionId>`.
-const PERSISTABLE_FIELDS = ['chatId', 'messageId', 'startTime', 'url', 'command', 'isolationBackend', 'sessionId', 'tool', 'infoBlock', 'urlContext', 'requesterUserId', 'showLimits', 'locale', 'logPath', 'args'];
+const PERSISTABLE_FIELDS = ['chatId', 'messageId', 'startTime', 'url', 'command', 'isolationBackend', 'sessionId', 'containerFilesystemStartBytes', 'tool', 'infoBlock', 'urlContext', 'requesterUserId', 'showLimits', 'locale', 'logPath', 'args'];
 
 /**
  * Resolve the directory durable bot state is written to. Honors

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.disk-diagnostics.lib.mjs

@@ -10,12 +10,8 @@
  *
  * Both checkpoints are written to the captured solve log as a single-line
  * structured marker. The Telegram bot's `session-monitor.lib.mjs` parses those
- * markers and, on the completion message, surfaces a Telegram block plus
- * warnings when any of the three thresholds from the issue are crossed:
- *
- *   - cloned repository  > WARNING_THRESHOLD_BYTES
- *   - delta during run   > WARNING_THRESHOLD_BYTES
- *   - total space used   > WARNING_THRESHOLD_BYTES
+ * markers and, on the completion message, surfaces a Telegram block plus a
+ * warning when total task disk usage crosses the configured threshold.
  *
  * Implementation notes:
  *
@@ -220,54 +216,79 @@ export function computeDiskWarnings(parsed, threshold = WARNING_THRESHOLD_BYTES)
 
 /**
  * Telegram block (Markdown code fence) describing the captured sizes plus,
- * when any threshold is crossed, a `⚠️ Warnings:` tail. Returns an empty
- * string when there are no markers in the log (no logs ⇒ no surprise output).
+ * when the task total crosses the threshold, a warning tail. Returns an empty
+ * string when there are no markers or docker container filesystem sizes to show
+ * (no logs ⇒ no surprise output).
  *
  * Returned shape:
  *
  *   💾 Disk usage (gh-issue-solver-…)
  *   ```
- *   Cloned repository: 12.0 GB
- *   After agent:       12.4 GB (+500.0 MB)
- *   Threshold:         5.0 GB
+ *   Repository size:
+ *     Cloned:          12.0 GB
+ *     On completion:   12.4 GB (+500 MB)
  *
- *   ⚠️ Cloned repository exceeds 5.0 GB
- *   ⚠️ Total disk usage exceeds 5.0 GB
+ *   ⚠️ Total disk usage per task exceeds 5.0 GB
  *   ```
  *
  * @param {{afterClone: object|null, afterAgent: object|null}} parsed
  * @param {Object} [options]
  * @param {number} [options.threshold=WARNING_THRESHOLD_BYTES]
  * @param {string} [options.title='💾 Disk usage']
+ * @param {string} [options.isolationBackend] - Adds container filesystem details for docker isolation.
+ * @param {number|null} [options.containerFilesystemStartBytes]
+ * @param {number|null} [options.containerFilesystemAfterBytes]
  * @returns {string}
  */
 export function formatDiskDiagnosticsBlock(parsed, options = {}) {
-  if (!parsed || (!parsed.afterClone && !parsed.afterAgent)) return '';
   const threshold = Number.isFinite(options.threshold) ? options.threshold : WARNING_THRESHOLD_BYTES;
   const title = options.title || '💾 Disk usage';
-  const warnings = computeDiskWarnings(parsed, threshold);
+  const isolationBackend = String(options.isolationBackend || '').toLowerCase();
+  const isDockerIsolation = isolationBackend === 'docker';
+  const containerFilesystemStartBytes = Number.isFinite(options.containerFilesystemStartBytes) ? options.containerFilesystemStartBytes : null;
+  const containerFilesystemAfterBytes = Number.isFinite(options.containerFilesystemAfterBytes) ? options.containerFilesystemAfterBytes : null;
+  const hasRepositoryMarkers = Boolean(parsed?.afterClone || parsed?.afterAgent);
+  const hasContainerFilesystemMarkers = isDockerIsolation && (containerFilesystemStartBytes !== null || containerFilesystemAfterBytes !== null);
+  if (!hasRepositoryMarkers && !hasContainerFilesystemMarkers) return '';
+
   const lines = [];
-  const cloneBytes = parsed.afterClone?.bytes ?? null;
-  const totalBytes = parsed.afterAgent?.bytes ?? null;
-  const deltaBytes = parsed.afterAgent?.deltaBytes ?? null;
-  if (cloneBytes !== null) {
-    lines.push(`Cloned repository: ${formatBytes(cloneBytes)}`);
+  const cloneBytes = parsed?.afterClone?.bytes ?? null;
+  const totalBytes = parsed?.afterAgent?.bytes ?? null;
+  const deltaBytes = parsed?.afterAgent?.deltaBytes ?? null;
+
+  const pushSizeLine = (label, bytes, suffix = '') => {
+    if (bytes === null) return;
+    lines.push(`  ${label.padEnd(16)} ${formatBytes(bytes)}${suffix}`);
+  };
+
+  if (hasRepositoryMarkers) {
+    lines.push('Repository size:');
+    pushSizeLine('Cloned:', cloneBytes);
+    if (totalBytes !== null) {
+      const deltaStr = deltaBytes !== null ? ` (${formatBytesDelta(deltaBytes)})` : '';
+      pushSizeLine('On completion:', totalBytes, deltaStr);
+    } else if (deltaBytes !== null) {
+      lines.push(`  ${'Delta during run:'.padEnd(16)} ${formatBytesDelta(deltaBytes)}`);
+    }
   }
-  if (totalBytes !== null) {
-    const deltaStr = deltaBytes !== null ? ` (${formatBytesDelta(deltaBytes)})` : '';
-    lines.push(`After agent:       ${formatBytes(totalBytes)}${deltaStr}`);
-  } else if (deltaBytes !== null) {
-    lines.push(`Delta during run:  ${formatBytesDelta(deltaBytes)}`);
+
+  if (hasContainerFilesystemMarkers) {
+    lines.push('Container filesystem size:');
+    pushSizeLine('On start:', containerFilesystemStartBytes);
+    pushSizeLine('On completion:', containerFilesystemAfterBytes);
   }
-  lines.push(`Threshold:         ${formatBytes(threshold)}`);
+
+  const taskTotalBytes = isDockerIsolation && containerFilesystemAfterBytes !== null ? containerFilesystemAfterBytes : (totalBytes ?? cloneBytes);
   const warningLines = [];
-  if (warnings.cloneTooLarge) warningLines.push(`⚠️ Cloned repository exceeds ${formatBytes(threshold)}`);
-  if (warnings.deltaTooLarge) warningLines.push(`⚠️ Folder grew by more than ${formatBytes(threshold)} during the run`);
-  if (warnings.totalTooLarge) warningLines.push(`⚠️ Total disk usage exceeds ${formatBytes(threshold)}`);
+  if (Number.isFinite(taskTotalBytes) && taskTotalBytes > threshold) {
+    warningLines.push(`⚠️ Total disk usage per task exceeds ${formatBytes(threshold)}`);
+  }
+
   if (warningLines.length) {
     lines.push('');
     lines.push(...warningLines);
   }
+
   return `${title}\n\`\`\`\n${lines.join('\n')}\n\`\`\``;
 }
 

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-command-execution.lib.mjs

@@ -127,6 +127,10 @@ export function buildExecuteAndUpdateMessage(deps) {
       trackSession(session, sessionInfo, VERBOSE);
       await safeEdit(formatStartingWorkSessionMessage({ sessionName: session, isolationBackend: iso.backend, infoBlock, locale }));
       result = await iso.runner.executeWithIsolation(commandName, args, { backend: iso.backend, sessionId: session, tool, verbose: VERBOSE });
+      if (result.success && sessionInfo && Number.isFinite(result.containerFilesystemStartBytes)) {
+        sessionInfo.containerFilesystemStartBytes = result.containerFilesystemStartBytes;
+        trackSession(session, sessionInfo, VERBOSE);
+      }
       if (!result.success) {
         // The launch never produced a live container — drop the optimistic
         // tracking so a phantom session is not monitored or resumed.

package/src/telegram-isolation.lib.mjs

@@ -92,6 +92,7 @@ export function createIsolationAwareQueueCallback(botIsolationBackend, botIsolat
             command: item.command || 'solve',
             isolationBackend: iso.backend,
             sessionId: sid,
+            containerFilesystemStartBytes: Number.isFinite(r.containerFilesystemStartBytes) ? r.containerFilesystemStartBytes : null,
             tool,
             infoBlock: item.infoBlock,
             // Issue #1688: propagate URL context + requester through the queue so the

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