@link-assistant/hive-mind 2.16.0 → 2.17.0

package/src/session-monitor.kill-sections.lib.mjs

@@ -95,6 +95,14 @@ export async function buildKillCompletionSections({ sessionName, sessionInfo, st
       exitCode,
       stopRequestedByUser: sessionInfo?.stopRequestedByUser === true,
       locale,
+      // start-command 0.33.0 scans the log tail for fatal markers when the
+      // command exits and reports what it found (link-foundation/start#164,
+      // #165 — both filed from this issue). Pass it through: `$` saw the exit
+      // live, so it can carry evidence our bounded re-read of a huge log may
+      // have missed. Absent on an older `$`, which is why the local scan stays.
+      reportedMemoryExhausted: statusResult?.memoryExhausted ?? null,
+      reportedMemoryExhaustedReason: statusResult?.memoryExhaustedReason ?? null,
+      reportedExitReason: statusResult?.exitReason ?? null,
     });
 
     const argv = argvFromSessionArgs(sessionInfo?.args);

package/src/session-store.lib.mjs

@@ -52,7 +52,7 @@ import path from 'node:path';
 //   - `stopRequestedByUser`/`stopRequestedBy` must survive a restart too: with
 //     `--on-session-kill=resume` now the default, forgetting that an operator
 //     asked for the stop would relaunch the very work they cancelled.
-const PERSISTABLE_FIELDS = ['chatId', 'messageId', 'startTime', 'url', 'command', 'commandAlias', 'isolationBackend', 'sessionId', 'executionUuid', 'containerFilesystemStartBytes', 'containerFilesystemLastBytes', 'containerFilesystemLastObservedAt', 'tool', 'infoBlock', 'urlContext', 'requesterUserId', 'showLimits', 'locale', 'logPath', 'args', 'completionNotifiedAt', 'completionExitCode', 'completionStatus', 'lastToolSessionId', 'killRecoveryAttempts', 'killRecoverySessionId', 'killRecoveryOfSession', 'killRecoveryResumed', 'stopRequestedByUser', 'stopRequestedBy', 'onSessionKill', 'resolvedPullRequestUrl'];
+const PERSISTABLE_FIELDS = ['chatId', 'messageId', 'startTime', 'url', 'command', 'commandAlias', 'isolationBackend', 'sessionId', 'executionUuid', 'containerFilesystemStartBytes', 'containerFilesystemLastBytes', 'containerFilesystemLastObservedAt', 'tool', 'infoBlock', 'urlContext', 'requesterUserId', 'showLimits', 'locale', 'logPath', 'args', 'completionNotifiedAt', 'completionExitCode', 'completionStatus', 'lastToolSessionId', 'killRecoveryAttempts', 'killRecoverySessionId', 'killRecoveryOfSession', 'killRecoveryResumed', 'killRecoveryInPlace', 'killRecoveryResumeMode', 'stopRequestedByUser', 'stopRequestedBy', 'onSessionKill', 'resolvedPullRequestUrl'];
 
 /**
  * Resolve the directory durable bot state is written to. Honors

package/src/solve.clone-errors.lib.mjs

@@ -0,0 +1,86 @@
+/**
+ * Clone failure classification and partial-clone cleanup for the solve command.
+ *
+ * Extracted from solve.repository.lib.mjs, which had grown past the 1350-line
+ * warning threshold that scripts/check-file-line-limits.sh enforces (issue
+ * #1593, surfaced again by issue #2198). These two helpers are pure decision
+ * logic with no dependency on the repository-setup flow around them, so they
+ * are the natural seam.
+ *
+ * Both names stay re-exported from solve.repository.lib.mjs so existing
+ * importers - and tests/anonymous-clone-auth-2192.test.mjs,
+ * tests/test-issue-1957-incomplete-clone.mjs - are unaffected.
+ */
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import { isENOSPC } from './lib.mjs';
+import { reportError } from './sentry.lib.mjs';
+// Issue #2192: GitHub throttles *anonymous* git downloads; the wording overlaps
+// the permission, not-found and rate-limit cases, so it is checked before them.
+import { isAnonymousDownloadLimit } from './git-auth-transport.lib.mjs';
+
+// Classify git clone errors to determine if they are retryable
+export const classifyCloneError = errorOutput => {
+  const output = errorOutput.toLowerCase();
+  // Issue #1211: ENOSPC (disk full) errors - NOT retryable, requires user action
+  if (isENOSPC(errorOutput) || output.includes('no space left on device') || (output.includes('unable to write file') && output.includes('error')) || output.includes('errno -28')) {
+    return { type: 'ENOSPC', retryable: false, description: 'No space left on device' };
+  }
+
+  // Transient server errors (5xx) - typically retryable
+  if (output.includes('error: 500') || output.includes('internal server error') || output.includes('error: 502') || output.includes('error: 503') || output.includes('error: 504')) {
+    return { type: 'TRANSIENT', retryable: true, description: 'GitHub server error' };
+  }
+  // Network-related errors - typically retryable
+  // Issue #1957: git fetch-pack/sideband disconnects (e.g.
+  // "fetch-pack: unexpected disconnect while reading sideband packet",
+  // "early EOF", "the remote end hung up unexpectedly", "RPC failed",
+  // "index-pack failed") leave an incomplete or missing clone but are transient.
+  if (output.includes('connection refused') || output.includes('connection timed out') || output.includes('connection reset') || output.includes('unable to connect') || output.includes('network is unreachable') || output.includes('ssl error') || output.includes('unexpected disconnect') || output.includes('sideband') || output.includes('early eof') || output.includes('remote end hung up') || output.includes('rpc failed') || output.includes('fetch-pack') || output.includes('index-pack failed') || output.includes('transfer closed')) {
+    return { type: 'NETWORK', retryable: true, description: 'Network connectivity issue (interrupted transfer)' };
+  }
+
+  // Issue #2192: GitHub refusing an *unauthenticated* download. Retryable, but
+  // waiting is not the remedy — the clone has to be authenticated. Checked
+  // before PERMISSION/NOT_FOUND/RATE_LIMIT because GitHub's wording ("limiting",
+  // "retry later or authenticate") overlaps all three.
+  if (isAnonymousDownloadLimit(errorOutput)) {
+    return { type: 'ANONYMOUS_RATE_LIMIT', retryable: true, description: 'GitHub is limiting unauthenticated downloads (this clone was not authenticated)' };
+  }
+
+  // Authentication/permission errors - not retryable
+  if (output.includes('error: 401') || output.includes('error: 403') || output.includes('authentication failed') || output.includes('permission denied')) {
+    return { type: 'PERMISSION', retryable: false, description: 'Authentication or permission error' };
+  }
+  // Repository not found - not retryable
+  if (output.includes('error: 404') || output.includes('not found') || output.includes('repository not found')) {
+    return { type: 'NOT_FOUND', retryable: false, description: 'Repository not found' };
+  }
+
+  // Rate limiting - retryable with backoff
+  if (output.includes('rate limit') || output.includes('too many requests') || output.includes('api rate limit exceeded')) {
+    return { type: 'RATE_LIMIT', retryable: true, description: 'Rate limit exceeded' };
+  }
+  // Default to retryable for unknown errors
+  return { type: 'UNKNOWN', retryable: true, description: 'Unknown error' };
+};
+
+// Issue #1957: remove leftovers from an interrupted clone so a retry can start clean.
+// We empty the directory in place (rather than removing it) because the path was
+// created up-front by setupTempDirectory and may be the configured working directory.
+export const cleanPartialClone = async tempDir => {
+  try {
+    const entries = await fs.readdir(tempDir);
+    for (const entry of entries) {
+      await fs.rm(path.join(tempDir, entry), { recursive: true, force: true });
+    }
+  } catch (error) {
+    // Directory may not exist yet, or be unreadable — non-fatal; the retry/clone
+    // will surface any real problem with a clearer message.
+    if (error?.code !== 'ENOENT') {
+      reportError(error, { context: 'clean_partial_clone', tempDir, operation: 'empty_directory' });
+    }
+  }
+};

package/src/solve.repository.lib.mjs

@@ -28,12 +28,13 @@ const { log, formatAligned } = lib;
 // Import exit handler
 import { safeExit } from './exit-handler.lib.mjs';
 import { ensureAiToolScratchIgnored } from './ai-tool-scratch.lib.mjs';
+import { reclaimAgentSnapshotStores } from './agent-snapshot-store.lib.mjs';
 import { parseForkFullNameFromGhOutput } from './github-repository-names.lib.mjs';
 import { checkReplacementRepositoryBranchSafety } from './solve.repository-safety.lib.mjs';
 import { buildForkReplacementBlockedReason, buildForkReplacementSafetyCheckDescription } from './solve.repository-recovery-message.lib.mjs';
 // Issue #2192: GitHub throttles *anonymous* git downloads; a token must be sent
 // preemptively (a credential helper is never consulted for a public repository).
-import { GIT_AUTH_TRANSPORT_DISABLE, ensureAuthenticatedGitTransport, isAnonymousDownloadLimit } from './git-auth-transport.lib.mjs';
+import { GIT_AUTH_TRANSPORT_DISABLE, ensureAuthenticatedGitTransport } from './git-auth-transport.lib.mjs';
 
 // Import GitHub utilities for permission checks
 const githubLib = await import('./github.lib.mjs');
@@ -931,69 +932,12 @@ Thank you!`;
 
   return { repoToClone, forkedRepo, upstreamRemote, prForkOwner: forkOwner };
 };
-// Classify git clone errors to determine if they are retryable
-export const classifyCloneError = errorOutput => {
-  const output = errorOutput.toLowerCase();
-  // Issue #1211: ENOSPC (disk full) errors - NOT retryable, requires user action
-  if (lib.isENOSPC(errorOutput) || output.includes('no space left on device') || (output.includes('unable to write file') && output.includes('error')) || output.includes('errno -28')) {
-    return { type: 'ENOSPC', retryable: false, description: 'No space left on device' };
-  }
-
-  // Transient server errors (5xx) - typically retryable
-  if (output.includes('error: 500') || output.includes('internal server error') || output.includes('error: 502') || output.includes('error: 503') || output.includes('error: 504')) {
-    return { type: 'TRANSIENT', retryable: true, description: 'GitHub server error' };
-  }
-  // Network-related errors - typically retryable
-  // Issue #1957: git fetch-pack/sideband disconnects (e.g.
-  // "fetch-pack: unexpected disconnect while reading sideband packet",
-  // "early EOF", "the remote end hung up unexpectedly", "RPC failed",
-  // "index-pack failed") leave an incomplete or missing clone but are transient.
-  if (output.includes('connection refused') || output.includes('connection timed out') || output.includes('connection reset') || output.includes('unable to connect') || output.includes('network is unreachable') || output.includes('ssl error') || output.includes('unexpected disconnect') || output.includes('sideband') || output.includes('early eof') || output.includes('remote end hung up') || output.includes('rpc failed') || output.includes('fetch-pack') || output.includes('index-pack failed') || output.includes('transfer closed')) {
-    return { type: 'NETWORK', retryable: true, description: 'Network connectivity issue (interrupted transfer)' };
-  }
-
-  // Issue #2192: GitHub refusing an *unauthenticated* download. Retryable, but
-  // waiting is not the remedy — the clone has to be authenticated. Checked
-  // before PERMISSION/NOT_FOUND/RATE_LIMIT because GitHub's wording ("limiting",
-  // "retry later or authenticate") overlaps all three.
-  if (isAnonymousDownloadLimit(errorOutput)) {
-    return { type: 'ANONYMOUS_RATE_LIMIT', retryable: true, description: 'GitHub is limiting unauthenticated downloads (this clone was not authenticated)' };
-  }
-
-  // Authentication/permission errors - not retryable
-  if (output.includes('error: 401') || output.includes('error: 403') || output.includes('authentication failed') || output.includes('permission denied')) {
-    return { type: 'PERMISSION', retryable: false, description: 'Authentication or permission error' };
-  }
-  // Repository not found - not retryable
-  if (output.includes('error: 404') || output.includes('not found') || output.includes('repository not found')) {
-    return { type: 'NOT_FOUND', retryable: false, description: 'Repository not found' };
-  }
+// Issue #2198: clone-failure classification and partial-clone cleanup live in
+// their own module to keep this file under the line-limit warning threshold.
+// Re-exported so importers keep working.
+import { classifyCloneError, cleanPartialClone } from './solve.clone-errors.lib.mjs';
 
-  // Rate limiting - retryable with backoff
-  if (output.includes('rate limit') || output.includes('too many requests') || output.includes('api rate limit exceeded')) {
-    return { type: 'RATE_LIMIT', retryable: true, description: 'Rate limit exceeded' };
-  }
-  // Default to retryable for unknown errors
-  return { type: 'UNKNOWN', retryable: true, description: 'Unknown error' };
-};
-
-// Issue #1957: remove leftovers from an interrupted clone so a retry can start clean.
-// We empty the directory in place (rather than removing it) because the path was
-// created up-front by setupTempDirectory and may be the configured working directory.
-export const cleanPartialClone = async tempDir => {
-  try {
-    const entries = await fs.readdir(tempDir);
-    for (const entry of entries) {
-      await fs.rm(path.join(tempDir, entry), { recursive: true, force: true });
-    }
-  } catch (error) {
-    // Directory may not exist yet, or be unreadable — non-fatal; the retry/clone
-    // will surface any real problem with a clearer message.
-    if (error?.code !== 'ENOENT') {
-      reportError(error, { context: 'clean_partial_clone', tempDir, operation: 'empty_directory' });
-    }
-  }
-};
+export { classifyCloneError, cleanPartialClone };
 // Clone repository and set up remotes with retry mechanism
 export const cloneRepository = async (repoToClone, tempDir, argv, owner, repo) => {
   const maxRetries = 3;
@@ -1340,6 +1284,30 @@ export const checkoutPrBranch = async (tempDir, branchName, prForkRemote, prFork
 
   return checkoutResult;
 };
+/**
+ * Reclaim orphaned `@link-assistant/agent` snapshot stores (issue #2186).
+ *
+ * Deliberately *not* gated on `--auto-cleanup`: the stores this removes belong to
+ * worktrees that no longer exist, so there is nothing left to restore them into
+ * and keeping them has no debugging value. On a public repository auto-cleanup
+ * defaults to off, and that must not also mean "leak ~5 GB/h of home-directory
+ * state that no Hive Mind disk check can even see".
+ *
+ * Never fatal: this runs while solve is finalizing, after the work is done.
+ */
+export const cleanupAgentSnapshotStores = async () => {
+  try {
+    const { removed } = await reclaimAgentSnapshotStores({ log: async (message, options) => log(message, options) });
+    if (removed.length > 0) await log(`🧹 Reclaimed ${removed.length} orphaned agent snapshot store(s)`);
+  } catch (cleanupError) {
+    reportError(cleanupError, {
+      context: 'cleanup_agent_snapshot_stores',
+      operation: 'reclaim_agent_snapshots',
+    });
+    await log(`⚠️  Could not reclaim orphaned agent snapshot stores: ${cleanupError.message}`, { level: 'warning' });
+  }
+};
+
 // Cleanup temporary directory
 export const cleanupTempDirectory = async (tempDir, argv, limitReached) => {
   // Determine if we should skip cleanup
@@ -1370,4 +1338,9 @@ export const cleanupTempDirectory = async (tempDir, argv, limitReached) => {
     const reason = argv.autoCleanupSource === 'repository-visibility-default' ? 'auto-cleanup is off by default for public repositories' : '--no-auto-cleanup';
     await log(`\n📁 Keeping directory (${reason}): ${tempDir}`);
   }
+
+  // Issue #2186: whatever was decided about the workspace above, agent state
+  // whose worktree is already gone is reclaimed. The store belonging to
+  // `tempDir` is untouched while `tempDir` still exists.
+  await cleanupAgentSnapshotStores();
 };

package/src/solve.resource-diagnostics.lib.mjs

@@ -2,6 +2,8 @@ import fs from 'node:fs';
 import os from 'node:os';
 import v8 from 'node:v8';
 
+import { measureAgentSnapshotUsage } from './agent-snapshot-store.lib.mjs';
+
 export const RESOURCE_MARKER_PREFIX = '📈 [RESOURCES]';
 
 export const RESOURCE_PHASE_SOLVE_START = 'solve_start';
@@ -327,6 +329,7 @@ export function buildResourceMarker(snapshot) {
   const cpu = s.cpu || {};
   const memory = s.memory || {};
   const disk = s.disk || {};
+  const agentState = s.agentState || null;
   return [
     RESOURCE_MARKER_PREFIX,
     `phase=${encodeValue(s.phase || 'snapshot')}`,
@@ -353,6 +356,11 @@ export function buildResourceMarker(snapshot) {
     `mem=${encodeValue(`${formatBytes(memory.availableBytes)} available / ${formatBytes(memory.totalBytes)} total`)}`,
     `heap=${encodeValue(formatHeapUsage(memory))}`,
     `disk=${encodeValue(`${formatBytes(disk.availableBytes)} available / ${formatBytes(disk.totalBytes)} total`)}`,
+    // Issue #2186: only emitted when the agent state was actually measured, so
+    // markers written before this existed keep parsing byte-for-byte the same.
+    agentState ? `agentStatePath=${encodeValue(agentState.path)}` : null,
+    agentState ? numberField('agentStoreCount', finiteNumber(agentState.count)) : null,
+    agentState ? numberField('agentStoreBytes', finiteNumber(agentState.bytes)) : null,
   ]
     .filter(Boolean)
     .join(' ');
@@ -404,6 +412,15 @@ function parseMarkerLine(line) {
       usedPercent: parseNumber(fields.diskUsedPercent),
       error: fields.error ? decodeURIComponent(fields.error) : null,
     },
+    // Issue #2186: absent in markers produced before agent state was measured,
+    // and absent on hosts where the agent data home does not exist.
+    agentState: fields.agentStatePath
+      ? {
+          path: decodeURIComponent(fields.agentStatePath),
+          count: parseNumber(fields.agentStoreCount),
+          bytes: parseNumber(fields.agentStoreBytes),
+        }
+      : null,
   };
 }
 
@@ -440,13 +457,18 @@ export function formatResourceSnapshotForLog(snapshot, label = null) {
   const memory = s.memory || {};
   const disk = s.disk || {};
   const lines = [`📈 Resource usage (${phaseLabel}):`, `   CPU load: ${formatNumber(cpu.load1)} ${formatNumber(cpu.load5)} ${formatNumber(cpu.load15)}${Number.isFinite(cpu.cpuCount) ? ` (${cpu.cpuCount} CPUs)` : ''}`, `   Memory: ${formatBytes(memory.availableBytes)} available / ${formatBytes(memory.totalBytes)} total (${formatBytes(memory.usedBytes)} used)`, `   Process RSS: ${formatBytes(memory.processRssBytes)}, V8 heap: ${formatHeapUsage(memory)}`, `   Disk (${disk.path || '/'}): ${formatBytes(disk.availableBytes)} available / ${formatBytes(disk.totalBytes)} total${Number.isFinite(disk.usedPercent) ? ` (${disk.usedPercent.toFixed(1)}% used)` : ''}`];
+  // Issue #2186: `/` alone hid ~5 GB/h of agent snapshot growth under
+  // `~/.local/share`, so name the directory that is actually filling up.
+  if (s.agentState && Number(s.agentState.count) > 0) {
+    lines.push(`   Agent snapshot stores (${s.agentState.path}): ${s.agentState.count} store(s), ${formatBytes(s.agentState.bytes)}${s.agentState.truncated ? '+ (measurement truncated)' : ''}`);
+  }
   if (isHeapUnderPressure(memory)) lines.push(`   ⚠️  V8 heap is at ${memory.processHeapUsedPercent.toFixed(1)}% of its limit — a further allocation can abort the process with "JavaScript heap out of memory"`);
   if (disk.error) lines.push(`   Disk probe error: ${disk.error}`);
   lines.push(buildResourceMarker(snapshot));
   return lines.join('\n');
 }
 
-export async function recordResourceSnapshot({ phase, log, diskPath = '/', label = null, capture = captureResourceSnapshot, logExecutionContext = false, detectContext = detectExecutionContext } = {}) {
+export async function recordResourceSnapshot({ phase, log, diskPath = '/', label = null, capture = captureResourceSnapshot, logExecutionContext = false, detectContext = detectExecutionContext, measureAgentState = measureAgentSnapshotUsage } = {}) {
   if (typeof log !== 'function') return null;
   try {
     // Issue #2001: optionally report the execution context (host vs container)
@@ -459,6 +481,17 @@ export async function recordResourceSnapshot({ phase, log, diskPath = '/', label
       }
     }
     const snapshot = capture({ phase, diskPath });
+    // Issue #2186: agent state lives outside `diskPath` and needs the file
+    // system, so it is measured separately and stays best-effort — a missing or
+    // unreadable agent data home must never cost us the rest of the snapshot.
+    if (typeof measureAgentState === 'function') {
+      try {
+        const agentState = await measureAgentState();
+        if (agentState && Number(agentState.count) > 0) snapshot.agentState = agentState;
+      } catch {
+        /* agent state is a diagnostic extra, not a precondition */
+      }
+    }
     await log(formatResourceSnapshotForLog(snapshot, label));
     return snapshot;
   } catch (error) {

package/src/start-command-cli.lib.mjs

@@ -0,0 +1,60 @@
+/**
+ * Shared access to the `$` CLI (start-command, link-foundation/start).
+ *
+ * Extracted from src/isolation-runner.lib.mjs (issue #2189) so the resume/attach
+ * wrappers added for `start-command@0.33.0` can reach the same lazily-loaded
+ * `command-stream` `$` and the same PATH lookup without importing the runner —
+ * which would create a cycle — and without duplicating either.
+ *
+ * @see https://github.com/link-foundation/start
+ * @see https://github.com/link-assistant/hive-mind/issues/2189
+ */
+
+import { ensureUseM } from './use-m-bootstrap.lib.mjs';
+
+/** The message every wrapper reports when `$` is not installed. */
+export const START_COMMAND_MISSING_ERROR = '`$` (start-command) binary not found on PATH. Install link-foundation/start.';
+
+let commandStreamDollarPromise = null;
+
+/**
+ * Lazily load `command-stream`'s `$` template tag.
+ *
+ * Cached across calls; a failed load clears the cache so a transient failure
+ * (a cold `use-m` fetch, say) does not poison every later call.
+ *
+ * @returns {Promise<Function>} The `$` template tag
+ */
+export async function getCommandStreamDollar() {
+  if (!commandStreamDollarPromise) {
+    commandStreamDollarPromise = (async () => {
+      if (typeof globalThis.use === 'undefined') {
+        await ensureUseM();
+      }
+      const { $ } = await globalThis.use('command-stream');
+      return $;
+    })();
+  }
+  try {
+    return await commandStreamDollarPromise;
+  } catch (error) {
+    commandStreamDollarPromise = null;
+    throw error;
+  }
+}
+
+/**
+ * Find the `$` CLI binary path.
+ *
+ * @returns {Promise<string|null>} Path to the `$` binary, or null when absent
+ */
+export async function findStartCommandBinary() {
+  try {
+    const $ = await getCommandStreamDollar();
+    const result = await $({ mirror: false })`which $`;
+    const resolved = result.stdout?.toString().trim() || '';
+    return resolved || null;
+  } catch {
+    return null;
+  }
+}

package/src/telegram-bot.mjs

@@ -27,10 +27,10 @@ const yargs = getLinoYargsFactory();
 const { createYargsConfig: createTelegramYargsConfig } = await import('./telegram.config.lib.mjs');
 const { createYargsConfig: createSolveYargsConfig, detectMalformedFlags } = await import('./solve.config.lib.mjs');
 const { createYargsConfig: createHiveYargsConfig } = await import('./hive.config.lib.mjs');
-const { enhanceUnknownArgumentError } = await import('./option-suggestions.lib.mjs');
 const { validateBranchInArgs } = await import('./solve.branch.lib.mjs');
 const { extractIsolationFromArgs, isValidPerCommandIsolation } = await import('./telegram-isolation.lib.mjs');
 const { mergeArgsWithOverrides } = await import('./args-overrides.lib.mjs'); // issue #2085
+const { validateCommandOverrides } = await import('./telegram-overrides-validation.lib.mjs'); // issue #2198
 const config = createTelegramYargsConfig(yargs(hideBin(process.argv))).parse();
 
 // Configuration priority: CLI option > --configuration LINO > .lenv > .env
@@ -109,96 +109,26 @@ if (ISOLATION_BACKEND) {
   }
 }
 
-// Validate solve overrides early using solve's yargs config
-// Only validate if solve command is enabled
-if (solveEnabled && solveOverrides.length > 0) {
-  console.log('Validating solve overrides...');
-  try {
-    const { backend: solveOverrideIsolation, filteredArgs: solveOverridesForValidation } = extractIsolationFromArgs(solveOverrides);
-    if (solveOverrideIsolation && !isValidPerCommandIsolation(solveOverrideIsolation)) {
-      throw new Error(`Invalid --isolation value '${solveOverrideIsolation}'. Must be: screen, tmux, or docker`);
-    }
-    // Add a dummy URL as the first argument (required positional for solve)
-    const testArgs = ['https://github.com/test/test/issues/1', ...solveOverridesForValidation];
-    // Temporarily suppress stderr to avoid yargs error output during validation
-    const originalStderrWrite = process.stderr.write;
-    const stderrBuffer = [];
-    process.stderr.write = chunk => {
-      stderrBuffer.push(chunk);
-      return true;
-    };
-
-    try {
-      // Use .parse() instead of yargs(args).parseSync() to ensure .strict() mode works
-      const testYargs = createSolveYargsConfig(yargs());
-      // Suppress yargs error output - we'll handle errors ourselves
-      testYargs
-        .exitProcess(false)
-        .showHelpOnFail(false)
-        .fail((msg, err) => {
-          if (err) throw err;
-          throw new Error(msg);
-        });
-      await testYargs.parse(testArgs);
-      // Issue #1482: Validate --base-branch in overrides early
-      const overrideBranchError = validateBranchInArgs(solveOverridesForValidation);
-      if (overrideBranchError) throw new Error(overrideBranchError);
-      console.log('✅ Solve overrides validated successfully');
-    } finally {
-      // Restore stderr
-      process.stderr.write = originalStderrWrite;
-    }
-  } catch (error) {
-    const enhancedError = enhanceUnknownArgumentError(error, createSolveYargsConfig(yargs()));
-    console.error(`❌ Invalid solve-overrides: ${enhancedError.message || String(enhancedError)}`);
-    console.error(`   Overrides: ${solveOverrides.join(' ')}`);
-    process.exit(1);
-  }
-}
-// Validate hive overrides early using hive's yargs config
-// Only validate if hive command is enabled
-if (hiveEnabled && hiveOverrides.length > 0) {
-  console.log('Validating hive overrides...');
-  try {
-    const { backend: hiveOverrideIsolation, filteredArgs: hiveOverridesForValidation } = extractIsolationFromArgs(hiveOverrides);
-    if (hiveOverrideIsolation && !isValidPerCommandIsolation(hiveOverrideIsolation)) {
-      throw new Error(`Invalid --isolation value '${hiveOverrideIsolation}'. Must be: screen, tmux, or docker`);
-    }
-    // Add a dummy URL as the first argument (required positional for hive)
-    const testArgs = ['https://github.com/test/test', ...hiveOverridesForValidation];
-
-    // Temporarily suppress stderr to avoid yargs error output during validation
-    const originalStderrWrite = process.stderr.write;
-    const stderrBuffer = [];
-    process.stderr.write = chunk => {
-      stderrBuffer.push(chunk);
-      return true;
-    };
-    try {
-      // Use .parse() instead of yargs(args).parseSync() to ensure .strict() mode works
-      const testYargs = createHiveYargsConfig(yargs());
-      // Suppress yargs error output - we'll handle errors ourselves
-      testYargs
-        .exitProcess(false)
-        .showHelpOnFail(false)
-        .fail((msg, err) => {
-          if (err) throw err;
-          throw new Error(msg);
-        });
-      await testYargs.parse(testArgs);
-      const overrideBranchError = validateBranchInArgs(hiveOverridesForValidation); // Issue #1482
-      if (overrideBranchError) throw new Error(overrideBranchError);
-      console.log('✅ Hive overrides validated successfully');
-    } finally {
-      // Restore stderr
-      process.stderr.write = originalStderrWrite;
-    }
-  } catch (error) {
-    const enhancedError = enhanceUnknownArgumentError(error, createHiveYargsConfig(yargs()));
-    console.error(`❌ Invalid hive-overrides: ${enhancedError.message || String(enhancedError)}`);
-    console.error(`   Overrides: ${hiveOverrides.join(' ')}`);
-    process.exit(1);
+// Validate solve/hive overrides early, using each command's own yargs config, so
+// a bad flag is rejected at startup instead of when the first session spawns
+// (issue #1209). The shared implementation lives in
+// telegram-overrides-validation.lib.mjs (issue #2198).
+for (const { enabled, label, flag, overrides, createYargsConfig, dummyUrl } of [
+  { enabled: solveEnabled, label: 'Solve', flag: 'solve-overrides', overrides: solveOverrides, createYargsConfig: createSolveYargsConfig, dummyUrl: 'https://github.com/test/test/issues/1' },
+  { enabled: hiveEnabled, label: 'Hive', flag: 'hive-overrides', overrides: hiveOverrides, createYargsConfig: createHiveYargsConfig, dummyUrl: 'https://github.com/test/test' },
+]) {
+  if (!enabled || overrides.length === 0) continue;
+
+  console.log(`Validating ${label.toLowerCase()} overrides...`);
+  const result = await validateCommandOverrides({ overrides, createYargsConfig, yargs, dummyUrl });
+  if (result.ok) {
+    console.log(`✅ ${label} overrides validated successfully`);
+    continue;
   }
+
+  console.error(`❌ Invalid ${flag}: ${result.message}`);
+  console.error(`   Overrides: ${overrides.join(' ')}`);
+  process.exit(1);
 }
 
 // Handle dry-run mode - exit after validation WITHOUT loading heavy dependencies
@@ -1252,7 +1182,17 @@ async function onBotLaunched() {
   // the monitor resumes watching — and finally reports any that were killed while
   // the bot was down. Done before starting the monitor so the first tick already
   // sees the resumed sessions.
-  await resumeSessionsOnLaunch({ resumeTrackedSessions, botStartTime: BOT_START_TIME, verbose: VERBOSE, logger: botLogger });
+  // Issue #2189: before replaying the durable store, let `$ --resume-all`
+  // settle the isolation backend's own record — a restart orphans the detached
+  // completion watchers, so an execution that ended while the bot was down has
+  // nobody left to write its exit.
+  await resumeSessionsOnLaunch({
+    resumeTrackedSessions,
+    reconcileIsolationSessions: typeof isolationRunner?.resumeAllIsolationSessions === 'function' ? ({ verbose }) => isolationRunner.resumeAllIsolationSessions({ verbose }) : null,
+    botStartTime: BOT_START_TIME,
+    verbose: VERBOSE,
+    logger: botLogger,
+  });
 
   startSessionMonitoringOnce();
   startFormalAiMaintenanceOnce();

package/src/telegram-overrides-validation.lib.mjs

@@ -0,0 +1,73 @@
+/**
+ * Early validation of --solve-overrides / --hive-overrides for the Telegram bot.
+ *
+ * Extracted from src/telegram-bot.mjs, which had grown past the 1350-line
+ * warning threshold that scripts/check-file-line-limits.sh enforces (issue
+ * #1593, surfaced again by issue #2198). The solve and hive blocks were
+ * near-identical copies of each other, so folding them into one parameterised
+ * function removes the duplication as well as the lines.
+ *
+ * Behaviour is unchanged and pinned by tests/test-telegram-bot-dry-run.mjs and
+ * tests/test-telegram-bot-configuration-isolation-links-notation.mjs, which
+ * assert on the exact console output the caller prints.
+ *
+ * The function reports rather than exits: the caller owns the messages and the
+ * exit code, which keeps this module testable in-process.
+ */
+
+import { enhanceUnknownArgumentError } from './option-suggestions.lib.mjs';
+import { validateBranchInArgs } from './solve.branch.lib.mjs';
+import { extractIsolationFromArgs, isValidPerCommandIsolation } from './telegram-isolation.lib.mjs';
+
+/**
+ * Parses `overrides` through the real yargs config of the target command, so an
+ * unknown or malformed flag is rejected at bot startup rather than when the
+ * first command spawns a session (issue #1209).
+ *
+ * @param {object} options
+ * @param {string[]} options.overrides       Override arguments to validate.
+ * @param {Function} options.createYargsConfig  The command's yargs config factory.
+ * @param {Function} options.yargs           A yargs factory (bound to Links Notation).
+ * @param {string} options.dummyUrl          Stand-in for the command's required positional.
+ * @returns {Promise<{ok: true} | {ok: false, message: string}>}
+ */
+export const validateCommandOverrides = async ({ overrides, createYargsConfig, yargs, dummyUrl }) => {
+  try {
+    const { backend: overrideIsolation, filteredArgs } = extractIsolationFromArgs(overrides);
+    if (overrideIsolation && !isValidPerCommandIsolation(overrideIsolation)) {
+      throw new Error(`Invalid --isolation value '${overrideIsolation}'. Must be: screen, tmux, or docker`);
+    }
+
+    const testArgs = [dummyUrl, ...filteredArgs];
+
+    // yargs writes its own diagnostics to stderr before the .fail() handler
+    // runs; suppress them so the caller's single message is what the operator
+    // sees.
+    const originalStderrWrite = process.stderr.write;
+    process.stderr.write = () => true;
+
+    try {
+      // .parse() rather than parseSync() so .strict() mode is honoured.
+      const testYargs = createYargsConfig(yargs());
+      testYargs
+        .exitProcess(false)
+        .showHelpOnFail(false)
+        .fail((msg, err) => {
+          if (err) throw err;
+          throw new Error(msg);
+        });
+      await testYargs.parse(testArgs);
+
+      // Issue #1482: --base-branch inside the overrides is validated too.
+      const overrideBranchError = validateBranchInArgs(filteredArgs);
+      if (overrideBranchError) throw new Error(overrideBranchError);
+    } finally {
+      process.stderr.write = originalStderrWrite;
+    }
+
+    return { ok: true };
+  } catch (error) {
+    const enhancedError = enhanceUnknownArgumentError(error, createYargsConfig(yargs()));
+    return { ok: false, message: enhancedError.message || String(enhancedError) };
+  }
+};

package/src/working-session-summary.lib.mjs

@@ -64,7 +64,7 @@ export const formatWorkingSessionSummaryMarkdown = text => {
   let inFence = false;
   let previousNonEmpty = '';
 
-  for (let index = 0; index < lines.length; ) {
+  for (let index = 0; index < lines.length;) {
     const line = lines[index];
     if (/^\s*(```|~~~)/.test(line)) {
       inFence = !inFence;