@link-assistant/hive-mind 2.15.2 → 2.17.0

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

@@ -24,7 +24,8 @@ import path from 'path';
 import os from 'os';
 import fs from 'fs/promises';
 import { constants as fsConstants } from 'fs';
-import { sanitizeForPublication, writeSanitizedPublicationFile } from './token-sanitization.lib.mjs';
+import { sanitizeForPublication } from './token-sanitization.lib.mjs';
+import { sanitizeLogFileToFileBounded } from './log-sanitize-worker.lib.mjs';
 import { safeReply, safeReplyWithDocument, safeSendDocument } from './telegram-safe-reply.lib.mjs';
 
 const UUID_RE = /\b([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\b/i;
@@ -43,8 +44,11 @@ async function prepareSanitizedLogUpload(logPath, caption) {
   const sanitizedPath = path.join(tempDir, path.basename(logPath));
 
   try {
-    const [rawLog, safeCaption] = await Promise.all([fs.readFile(logPath, 'utf8'), sanitizeForPublication(caption)]);
-    await writeSanitizedPublicationFile(sanitizedPath, rawLog);
+    // Issue #2189: `/log` accepts files up to Telegram's 50 MB document limit,
+    // and this used to hold the log twice (raw string + sanitized string) plus a
+    // third copy inside the sanitizer. The streaming sanitizer writes the same
+    // artifact one block at a time, so a 50 MB log costs the same as a 50 kB one.
+    const [, safeCaption] = await Promise.all([sanitizeLogFileToFileBounded({ sourcePath: logPath, destPath: sanitizedPath }), sanitizeForPublication(caption)]);
     return {
       path: sanitizedPath,
       caption: safeCaption,

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/telegram-terminal-watch-command.lib.mjs

@@ -7,6 +7,7 @@
 
 import fs from 'fs/promises';
 import { extractSessionIdFromText, decideLogDestination, resolveLogPath } from './telegram-log-command.lib.mjs';
+import { readLogTailText } from './log-bounded-read.lib.mjs';
 import { parseSessionExitFooter } from './isolation-runner.lib.mjs';
 import { safeReply, safeSendMessage, safeEditMessageText } from './telegram-safe-reply.lib.mjs';
 import { classifyExitStatus, isFailureSessionStatus } from './session-status.lib.mjs';
@@ -15,6 +16,11 @@ const DEFAULT_WIDTH = 120;
 const DEFAULT_HEIGHT = 25;
 const DEFAULT_INTERVAL_MS = 2500;
 const DEFAULT_MAX_CHARS = 3400;
+// Issue #2189: the watch loop re-reads the log every `intervalMs`, but it only
+// ever renders the last `height` lines and looks for the exit footer, both of
+// which live at the very end. Reading the whole file made a poll tick cost
+// O(log size) — a 134 MB session log allocated 134 MB of string per tick.
+const TERMINAL_WATCH_TAIL_BYTES = 256 * 1024;
 const GITHUB_URL_RE = /https:\/\/github\.com\/[^\s"'`<>]+/i;
 const activeWatches = new Map();
 
@@ -141,7 +147,9 @@ export function formatTerminalWatchMessage({ sessionId, statusResult = null, log
 
 async function readLogFile(logPath) {
   try {
-    return await fs.readFile(logPath, 'utf8');
+    const { size } = await fs.stat(logPath);
+    if (!size) return '';
+    return await readLogTailText(logPath, { maxBytes: TERMINAL_WATCH_TAIL_BYTES });
   } catch (error) {
     if (error?.code === 'ENOENT') return '';
     throw error;

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;