@link-assistant/hive-mind 2.1.6 → 2.1.8

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @link-assistant/hive-mind
 
+## 2.1.8
+
+### Patch Changes
+
+- 11dab3c: Handle Telegram and CLI commands where a GitHub issue or pull request URL is immediately followed by a long option marker.
+
+## 2.1.7
+
+### Patch Changes
+
+- 0ce779b: Enforce the solve queue minimum start interval for immediate Telegram `/solve`
+  launches so direct starts consume the same global pacing slot as queued starts.
+
 ## 2.1.6
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "2.1.6",
+  "version": "2.1.8",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",

package/src/argument-normalization.lib.mjs

@@ -0,0 +1,23 @@
+const TYPOGRAPHIC_LONG_OPTION_DASHES = /[\u2013\u2014]/g;
+
+const GITHUB_ISSUE_OR_PR_WITH_JOINED_OPTION = new RegExp(['^(', '(?:https?://)?', '(?:www\\.)?', '(?:github\\.com/)?', '[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+/(?:issues|pull)/\\d+', ')', '(--[A-Za-z][A-Za-z0-9-]*(?:=.*)?)', '$'].join(''));
+
+export const normalizeTypographicOptionDashes = value => {
+  if (typeof value !== 'string') return value;
+  return value.replace(TYPOGRAPHIC_LONG_OPTION_DASHES, '--');
+};
+
+export const splitJoinedGitHubLongOptionArg = value => {
+  const normalized = normalizeTypographicOptionDashes(value);
+  if (typeof normalized !== 'string') return [normalized];
+
+  const match = normalized.match(GITHUB_ISSUE_OR_PR_WITH_JOINED_OPTION);
+  if (!match) return [normalized];
+
+  return [match[1], match[2]];
+};
+
+export const normalizeCliArgs = args => {
+  if (!Array.isArray(args)) return [];
+  return args.flatMap(splitJoinedGitHubLongOptionArg);
+};

package/src/cli-arguments.lib.mjs

@@ -1,8 +1,10 @@
 import { getenv, makeConfig, yargs as linoYargs } from 'lino-arguments';
 
+import { normalizeCliArgs } from './argument-normalization.lib.mjs';
 import { enhanceUnknownArgumentError } from './option-suggestions.lib.mjs';
 
 export { getenv };
+export { normalizeCliArgs, normalizeTypographicOptionDashes, splitJoinedGitHubLongOptionArg } from './argument-normalization.lib.mjs';
 
 export const hideBin = argv => argv.slice(2);
 
@@ -53,7 +55,7 @@ export function addCliCompatibilityAliases(parsed, { positionalAliases = [] } =
 }
 
 export function parseCliArgumentsWithLino({ argv = process.argv, commandName = 'cli', createYargsConfig, positionalAliases = [], lenv = { enabled: true }, env = { enabled: false }, getenv: getenvOptions = { enabled: true } } = {}) {
-  const fullArgv = ensureFullArgv(argv, commandName);
+  const fullArgv = normalizeCliArgs(ensureFullArgv(argv, commandName));
   let configuredParser = null;
   let parsed;
 

package/src/hive.mjs

@@ -18,9 +18,9 @@ if (earlyArgs.includes('--version')) {
 if (earlyArgs.includes('--help') || earlyArgs.includes('-h')) {
   try {
     // Load minimal modules needed for help
-    const { getLinoYargsFactory, hideBin } = await import('./cli-arguments.lib.mjs');
+    const { getLinoYargsFactory, hideBin, normalizeCliArgs } = await import('./cli-arguments.lib.mjs');
     const yargs = getLinoYargsFactory();
-    const rawArgs = hideBin(process.argv);
+    const rawArgs = normalizeCliArgs(hideBin(process.argv));
     // Reuse createYargsConfig from shared module to avoid duplication
     const { createYargsConfig } = await import('./hive.config.lib.mjs');
     const helpYargs = createYargsConfig(yargs(rawArgs)).version(false);
@@ -62,7 +62,7 @@ if (isRunningDirectly) {
       30000, // 30 second timeout
       'loading command-stream'
     );
-    const { parseCliArgumentsWithLino, hideBin } = await import('./cli-arguments.lib.mjs');
+    const { parseCliArgumentsWithLino, hideBin, normalizeCliArgs } = await import('./cli-arguments.lib.mjs');
     const path = (await withTimeout(use('path'), 30000, 'loading path')).default;
     const fs = (await withTimeout(use('fs'), 30000, 'loading fs')).promises;
     // Import shared library functions
@@ -225,7 +225,7 @@ if (isRunningDirectly) {
     }
 
     // Configure command line arguments - GitHub URL as positional argument
-    const rawArgs = hideBin(process.argv);
+    const rawArgs = normalizeCliArgs(hideBin(process.argv));
     // Use .parse() instead of .argv to ensure .strict() mode works correctly
     // When you use .argv, strict mode doesn't trigger properly
     // See: https://github.com/yargs/yargs/issues - .strict() only works with .parse()
@@ -248,7 +248,7 @@ if (isRunningDirectly) {
 
     try {
       argv = parseCliArgumentsWithLino({
-        argv: process.argv,
+        argv: ['node', 'hive', ...rawArgs],
         commandName: 'hive',
         createYargsConfig,
         positionalAliases: ['github-url'],

package/src/queue-start-reservation.lib.mjs

@@ -0,0 +1,41 @@
+const reservationLocks = new WeakMap();
+
+function getReservationLock(queue) {
+  return reservationLocks.get(queue) || Promise.resolve();
+}
+
+/**
+ * Atomically check and reserve the global startup slot for direct execution.
+ *
+ * Queue consumer starts are naturally serialized. Telegram direct starts need
+ * the same serialization because overlapping handlers can both pass resource
+ * checks before the first detached process is visible to process scanning.
+ *
+ * @param {Object} queue - SolveQueue-like object.
+ * @param {Object} options - Same options as queue.canStartCommand().
+ * @returns {Promise<Object>} canStartCommand() result plus reservation fields.
+ */
+export async function reserveStartSlotForQueue(queue, options = {}) {
+  const previousReservation = getReservationLock(queue);
+  let releaseReservation;
+  reservationLocks.set(
+    queue,
+    new Promise(resolve => {
+      releaseReservation = resolve;
+    })
+  );
+
+  await previousReservation.catch(() => {});
+
+  try {
+    const check = await queue.canStartCommand(options);
+    if (!check.canStart) {
+      return { ...check, startReserved: false };
+    }
+
+    const reservedStartTime = queue.recordStart(options.tool || 'claude');
+    return { ...check, startReserved: true, reservedStartTime };
+  } finally {
+    releaseReservation();
+  }
+}

package/src/solve.config.lib.mjs

@@ -11,7 +11,7 @@ import { enhanceErrorMessage, detectMalformedFlags } from './option-suggestions.
 import { defaultModels, buildModelOptionDescription, resolveDefaultFallbackModel, resolveRuntimeDefaultModel } from './models/index.mjs';
 import { validateBranchName } from './solve.branch.lib.mjs';
 import { resolveEscalationConfig, isEscalateEnabled, DEFAULT_ESCALATE_RANGE } from './solve.escalate.lib.mjs';
-import { getLinoYargsFactory, hideBin, parseCliArgumentsWithLino } from './cli-arguments.lib.mjs';
+import { getLinoYargsFactory, hideBin, normalizeCliArgs, parseCliArgumentsWithLino } from './cli-arguments.lib.mjs';
 
 // Re-export for use by telegram-bot.mjs (avoids extra import lines there)
 export { detectMalformedFlags };
@@ -737,7 +737,7 @@ export const createYargsConfig = yargsInstance => {
 
 // Parse command line arguments - now needs yargs and hideBin passed in
 export const parseArguments = async (yargs = getLinoYargsFactory(), hideBinFn = hideBin) => {
-  const rawArgs = hideBinFn(process.argv);
+  const rawArgs = normalizeCliArgs(hideBinFn(process.argv));
 
   // Issue #1092: Detect malformed flag patterns BEFORE yargs parsing
   // This catches cases like "-- model" which yargs silently treats as positional arguments
@@ -776,7 +776,7 @@ export const parseArguments = async (yargs = getLinoYargsFactory(), hideBinFn =
     try {
       yargsInstance = createYargsConfig(yargs());
       argv = parseCliArgumentsWithLino({
-        argv: process.argv,
+        argv: ['node', 'solve', ...rawArgs],
         commandName: 'solve',
         createYargsConfig,
         positionalAliases: ['issue-url'],

package/src/telegram-bot.mjs

@@ -916,8 +916,9 @@ async function handleSolveCommand(ctx) {
     await safeReply(ctx, t('telegram.url_session_running', { url: escapeMarkdown(normalizedUrl), session: activeSession.sessionName }, { locale: solveLocale }), { reply_to_message_id: ctx.message.message_id });
     return;
   }
-  const check = await solveQueue.canStartCommand({ tool: solveTool, locale: solveLocale }); // Skip Claude limits for agent (#1159)
   const queueStats = solveQueue.getStats();
+  const hasPendingQueueItems = queueStats.queued > 0;
+  const check = hasPendingQueueItems ? await solveQueue.canStartCommand({ tool: solveTool, locale: solveLocale }) : await solveQueue.reserveStartSlot({ tool: solveTool, locale: solveLocale }); // Skip Claude limits for agent (#1159)
   // Handle rejection: threshold strategy is 'reject' — fail immediately (issue #1267)
   if (check.rejected) {
     await safeReply(ctx, t('telegram.solve_rejected', { infoBlock, reason: escapeMarkdown(check.rejectReason || 'Unknown') }, { locale: solveLocale }), { reply_to_message_id: ctx.message.message_id });
@@ -935,18 +936,18 @@ async function handleSolveCommand(ctx) {
   let solveLimitsAtStart = null;
   if (solveShowLimits) ({ infoBlock, limitsAtStart: solveLimitsAtStart } = await captureStartSnapshotAndAppend({ infoBlock, tool: solveTool, verbose: VERBOSE, limitsLib, commandLabel: '/solve', locale: solveLocale }));
 
-  if (check.canStart && toolQueuedCount === 0) {
+  if (check.canStart && check.startReserved) {
     const startingMessage = await safeReply(ctx, formatStartingWorkSessionMessage({ infoBlock, locale: solveLocale }), { reply_to_message_id: ctx.message.message_id });
     await executeAndUpdateMessage(ctx, startingMessage, 'solve', argsWithLocale, infoBlock, effectiveSolveIsolation, solveTool, solveUrlContext, { showLimits: solveShowLimits, limitsAtStart: solveLimitsAtStart, locale: solveLocale });
   } else {
-    const queueItem = solveQueue.enqueue({ url: normalizedUrl, args: argsWithLocale, ctx, requester, infoBlock, tool: solveTool, perCommandIsolation: effectiveSolveIsolation, urlContext: solveUrlContext, showLimits: solveShowLimits, limitsAtStart: solveLimitsAtStart, locale: solveLocale });
-    const queueMessage = buildSolveQueuedMessage({ locale: solveLocale, tool: solveTool, position: toolQueuedCount + 1, infoBlock, reason: check.reason ? escapeMarkdown(check.reason) : '' }); // tool-specific position (#1551)
-    const queuedMessage = await safeReply(ctx, queueMessage, { reply_to_message_id: ctx.message.message_id });
-    queueItem.messageInfo = { chatId: queuedMessage.chat.id, messageId: queuedMessage.message_id };
     if (!solveQueue.executeCallback) {
       const _t = (s, i) => trackSession(s, i, VERBOSE);
       solveQueue.executeCallback = createIsolationAwareQueueCallback(ISOLATION_BACKEND, isolationRunner, _t, createQueueExecuteCallback(executeStartScreen, _t), VERBOSE);
     }
+    const queueItem = solveQueue.enqueue({ url: normalizedUrl, args: argsWithLocale, ctx, requester, infoBlock, tool: solveTool, perCommandIsolation: effectiveSolveIsolation, urlContext: solveUrlContext, showLimits: solveShowLimits, limitsAtStart: solveLimitsAtStart, locale: solveLocale });
+    const queueMessage = buildSolveQueuedMessage({ locale: solveLocale, tool: solveTool, position: toolQueuedCount + 1, infoBlock, reason: check.reason ? escapeMarkdown(check.reason) : '' }); // tool-specific position (#1551)
+    const queuedMessage = await safeReply(ctx, queueMessage, { reply_to_message_id: ctx.message.message_id });
+    queueItem.messageInfo = { chatId: queuedMessage.chat.id, messageId: queuedMessage.message_id };
   }
 }
 

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

@@ -8,6 +8,7 @@
  * @see https://github.com/link-assistant/hive-mind/issues/1618
  */
 
+import { normalizeCliArgs } from './argument-normalization.lib.mjs';
 import { enhanceUnknownArgumentError } from './option-suggestions.lib.mjs';
 
 export const TOOL_SOLVE_COMMAND_ALIASES = Object.freeze({
@@ -29,16 +30,13 @@ export function parseCommandArgs(text) {
     return [];
   }
 
-  // Replace em-dash with double-dash to fix Telegram auto-replacement.
-  const normalizedArgsText = argsText.replace(/—/g, '--');
-
   const args = [];
   let currentArg = '';
   let inQuotes = false;
   let quoteChar = null;
 
-  for (let i = 0; i < normalizedArgsText.length; i++) {
-    const char = normalizedArgsText[i];
+  for (let i = 0; i < argsText.length; i++) {
+    const char = argsText[i];
 
     if ((char === '"' || char === "'") && !inQuotes) {
       inQuotes = true;
@@ -60,7 +58,7 @@ export function parseCommandArgs(text) {
     args.push(currentArg);
   }
 
-  return args;
+  return normalizeCliArgs(args);
 }
 
 function toCamelCaseOptionName(name) {

package/src/telegram-solve-queue.lib.mjs

@@ -20,6 +20,7 @@ export { formatDuration, getRunningAgentProcesses, getRunningClaudeProcesses, ge
 import { collectExecutingItems, formatDuration, formatQueueToolSection, formatWaitingReason, getRunningAgentProcesses, getRunningClaudeProcesses, getRunningCodexProcesses, getRunningGeminiProcesses, getRunningProcesses, getRunningQwenProcesses, getRunningSessionItems, groupQueueItemsByTool } from './telegram-solve-queue.helpers.lib.mjs';
 export { QUEUE_CONFIG, THRESHOLD_STRATEGIES } from './queue-config.lib.mjs';
 import { QUEUE_CONFIG } from './queue-config.lib.mjs';
+import { reserveStartSlotForQueue } from './queue-start-reservation.lib.mjs';
 import { formatExecutingWorkSessionMessage, formatStartingWorkSessionMessage } from './work-session-formatting.lib.mjs';
 import { t } from './i18n.lib.mjs';
 import { lt } from './limits-i18n.lib.mjs';
@@ -373,6 +374,16 @@ export class SolveQueue {
     return count;
   }
 
+  recordStart(tool = 'claude', startTime = Date.now()) {
+    this.lastStartTimeByTool[tool] = startTime;
+    this.lastStartTime = startTime;
+    return startTime;
+  }
+
+  reserveStartSlot(options = {}) {
+    return reserveStartSlotForQueue(this, options);
+  }
+
   /**
    * Find the next startable item across all tool queues.
    * With separate queues, each tool is checked independently so tool-specific
@@ -1074,7 +1085,7 @@ export class SolveQueue {
    * - Each tool queue is checked independently
    * - Claude limits only affect Claude queue
    * - Agent queue can proceed even when Claude is blocked (and vice versa)
-   * - Multiple items can start in the same cycle (one per tool)
+   * - The oldest startable item starts each cycle to preserve global pacing
    *
    * @see https://github.com/link-assistant/hive-mind/issues/1159
    */
@@ -1088,9 +1099,6 @@ export class SolveQueue {
         continue;
       }
 
-      // Find startable items from each tool queue
-      // Each tool is checked independently so they don't block each other
-      // See: https://github.com/link-assistant/hive-mind/issues/1159
       const startableItems = await this.findStartableItems();
 
       if (startableItems.length === 0) {
@@ -1101,8 +1109,6 @@ export class SolveQueue {
         continue;
       }
 
-      // Start items from each tool that can proceed
-      // This allows parallel starts from different tool queues
       for (const startable of startableItems) {
         const { tool } = startable;
         const toolQueue = this.getToolQueue(tool);
@@ -1115,12 +1121,9 @@ export class SolveQueue {
         item.setStarting();
         this.processing.set(item.id, item);
 
-        // Update tool-specific last start time
-        this.lastStartTimeByTool[tool] = Date.now();
-        this.lastStartTime = Date.now(); // Legacy compatibility
+        this.recordStart(tool);
         this.stats.totalStarted++;
 
-        // Update message to show Starting status
         await this.updateItemMessage(item, formatStartingWorkSessionMessage({ infoBlock: item.infoBlock, locale: item.locale }));
 
         this.log(`Starting: ${item.toString()} from ${tool} queue`);