@link-assistant/hive-mind 2.16.0 → 2.18.0

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
@@ -239,6 +169,8 @@ const { formatUsageMessage, formatCodexLimitsSection, getAllCachedLimits } = lim
 const { handleShowLimitsFlag, captureStartSnapshotAndAppend } = await import('./telegram-show-limits.lib.mjs'); // #594
 const { getVersionInfo, formatVersionMessage } = await import('./version-info.lib.mjs');
 const { escapeMarkdown, escapeMarkdownV2, cleanNonPrintableChars, makeSpecialCharsVisible } = await import('./telegram-markdown.lib.mjs');
+const { formatUrlRepairs, hasNotableRepair, namesGitHubHost, revealHiddenCharacters } = await import('./github-url-recovery.lib.mjs'); // #2194
+
 const { getSolveQueue, createQueueExecuteCallback } = await import('./telegram-solve-queue.lib.mjs');
 const { applySolveToolAlias, getFirstParsedPositionalArg, getSolveCommandNameFromText, getSolveToolAliasFromText, moveArgumentToFront, parseArgsWithYargs, parseCommandArgs, SOLVE_COMMAND_NAMES } = await import('./telegram-solve-command.lib.mjs');
 const { executeStartScreen: executeStartScreenCommand, buildExecuteAndUpdateMessage } = await import('./telegram-command-execution.lib.mjs');
@@ -385,22 +317,28 @@ async function validateGitHubUrl(args, options = {}) {
   if (!rawUrl) return { valid: false, error: t('telegram.missing_github_url', { commandName }, { locale }) };
   // Issue #1102: Clean non-printable chars (Zero-Width Space, BOM, etc.) from URLs
   const url = cleanNonPrintableChars(rawUrl);
-  if (!url.includes('github.com')) return { valid: false, error: t('telegram.first_arg_must_be_github_url', {}, { locale }) };
+  // Issue #2194: the host may be typed in any case (GITHUB.COM) or hidden behind
+  // look-alike punctuation, and "github.com" in the path of another host is not a
+  // GitHub URL at all — so the recovery layer's host check makes the call, not a
+  // substring test that both misses the first case and accepts the second.
+  if (!namesGitHubHost(url)) return { valid: false, error: t('telegram.first_arg_must_be_github_url', {}, { locale }) };
   const parsed = parseGitHubUrl(url);
   if (!parsed.valid) return { valid: false, error: parsed.error || 'Invalid GitHub URL', suggestion: parsed.suggestion };
+  // Issue #2194: tell the user which URL we actually understood when we had to repair theirs.
+  const recoveryNotice = hasNotableRepair(parsed.repairs) ? t('telegram.url_recovered', { original: escapeMarkdown(makeSpecialCharsVisible(rawUrl)), used: escapeMarkdown(parsed.canonical), repairs: escapeMarkdown(formatUrlRepairs(parsed.repairs, { notableOnly: true })) }, { locale }) : null;
   if (!allowedTypes.includes(parsed.type)) {
     const allowedTypesStr = allowedTypes.map(t => (t === 'pull' ? 'pull request' : t)).join(', ');
     const baseUrl = `https://github.com/${parsed.owner}/${parsed.repo}`;
     const escapedUrl = escapeMarkdown(url),
       escapedBaseUrl = escapeMarkdown(baseUrl); // Issue #1102: escape for Markdown
     let error;
-    if (parsed.type === 'issues_list') error = t('telegram.url_issues_list_error', { url: escapedUrl, example: `${escapedBaseUrl}/issues/1` }, { locale });
-    else if (parsed.type === 'pulls_list') error = t('telegram.url_pulls_list_error', { url: escapedUrl, example: `${escapedBaseUrl}/pull/1` }, { locale });
+    if (parsed.type === 'issues_list') error = t('telegram.url_issues_list_error', { url: escapedBaseUrl, example: `${escapedBaseUrl}/issues/1` }, { locale });
+    else if (parsed.type === 'pulls_list') error = t('telegram.url_pulls_list_error', { url: escapedBaseUrl, example: `${escapedBaseUrl}/pull/1` }, { locale });
     else if (parsed.type === 'repo') error = t('telegram.url_repo_error', { allowedTypes: allowedTypesStr, url: escapedUrl, example: `${escapedBaseUrl}/issues/1` }, { locale });
     else error = t('telegram.url_must_be_type', { allowedTypes: allowedTypesStr, type: parsed.type.replace('_', ' ') }, { locale });
     return { valid: false, error };
   }
-  return { valid: true, parsed, normalizedUrl: url };
+  return { valid: true, parsed, normalizedUrl: url, recoveryNotice };
 }
 
 const executeAndUpdateMessage = buildExecuteAndUpdateMessage({ resolveIsolation, ISOLATION_BACKEND, isolationRunner, VERBOSE, executeStartScreen, trackSession, untrackSession, AUTO_WATCH_MESSAGE, startAutoTerminalWatchForSession, bot, formatExecutingWorkSessionMessage, formatStartingWorkSessionMessage });
@@ -609,6 +547,10 @@ async function handleSolveCommand(ctx) {
   }
 
   VERBOSE && console.log(`[VERBOSE] ${solveCommandDisplay} passed all checks, executing...`);
+  // Issue #2194: the incoming text is the only record of what the user actually
+  // typed, and the log for that issue did not contain it — so an invisible
+  // character in the URL was invisible in the log too. Reveal it here.
+  VERBOSE && console.log(`[VERBOSE] ${solveCommandDisplay} raw text: ${revealHiddenCharacters(ctx.message.text)}`);
   const solveToolAlias = getSolveToolAliasFromText(ctx.message.text);
   let userArgs = parseCommandArgs(ctx.message.text);
 
@@ -677,6 +619,8 @@ async function handleSolveCommand(ctx) {
     await safeReply(ctx, errorMsg, { reply_to_message_id: ctx.message.message_id });
     return;
   }
+  // Issue #2194: the link needed repair, so show what we understood before we act on it.
+  if (validation.recoveryNotice) await safeReply(ctx, validation.recoveryNotice, { reply_to_message_id: ctx.message.message_id });
   userArgs = moveArgumentToFront(userArgs, validation.normalizedUrl, cleanNonPrintableChars);
   // Issue #2166: hand the spawned session the same canonical URL that is shown
   // in the chat, so the echo and the actual work can never disagree.
@@ -896,6 +840,8 @@ async function handleHiveCommand(ctx) {
     await safeReply(ctx, errorMsg, { reply_to_message_id: ctx.message.message_id });
     return;
   }
+  // Issue #2194: the link needed repair, so show what we understood before we act on it.
+  if (validation.recoveryNotice) await safeReply(ctx, validation.recoveryNotice, { reply_to_message_id: ctx.message.message_id });
   // Normalize issues_list/pulls_list to base repo URL, or use cleaned URL
   let normalizedArgs = moveArgumentToFront(userArgs, validation.normalizedUrl, cleanNonPrintableChars);
   const p = validation.parsed;
@@ -1252,7 +1198,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;