@link-assistant/hive-mind 1.74.7 → 1.74.8

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @link-assistant/hive-mind
 
+## 1.74.8
+
+### Patch Changes
+
+- c132ce0: Fix `/stop <issue-or-pr-url>` so it can stop tasks that started immediately
+  (empty queue) or were already dispatched to a detached isolation session. The
+  URL lookup now also consults the session-monitor registry and forwards CTRL+C
+  to the tracked start-command UUID, so all three stop modes (issue URL, PR URL,
+  and session UUID) work end-to-end (#1871).
+
 ## 1.74.7
 
 ### Patch Changes

package/package.json

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

package/src/session-monitor.lib.mjs

@@ -150,7 +150,11 @@ function isMessageAlreadyUpdatedError(error) {
 }
 
 function normalizeSessionUrl(url) {
-  return url.replace(/\/+$/, '').replace(/#.*$/, '').toLowerCase();
+  // Strip the fragment first, then any trailing slashes, so URLs that carry a
+  // fragment after a trailing slash (e.g. `.../issues/18/#comment`) normalize to
+  // the same value as the bare `.../issues/18`. Doing it in the other order
+  // would leave a dangling trailing slash. (Issue #1871.)
+  return url.replace(/#.*$/, '').replace(/\/+$/, '').toLowerCase();
 }
 
 function isNonIsolationSessionActive(sessionName, sessionInfo, verbose = false) {
@@ -488,6 +492,73 @@ export function hasActiveSessionForUrl(url, verbose = false) {
   return { isActive: false, sessionName: null };
 }
 
+const SESSION_UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+/**
+ * Issue #1871: Find a tracked, still-running session for a GitHub issue/PR URL
+ * and report whether it can be stopped by forwarding CTRL+C to the
+ * start-command session UUID.
+ *
+ * The `/stop <url>` Telegram flow originally consulted only the in-memory solve
+ * queue. But a `/solve` or `/codex` that starts immediately (queue empty)
+ * dispatches straight to a detached isolation session and is removed from the
+ * queue's `processing` Map the moment it is launched. From that point on the
+ * session-monitor's in-memory registry is the only place that still knows the
+ * URL → start-command-UUID mapping, so `/stop <url>` reported "no task found"
+ * even though the task was clearly running. This helper exposes that registry
+ * so the stop flow can recover the UUID and interrupt the session.
+ *
+ * A session is stoppable when it was launched with an isolation backend and its
+ * start-command UUID is UUID-shaped (the value `$ --stop <uuid>` expects). Plain
+ * non-isolation screen sessions are reported but marked `stoppable: false`
+ * because `$ --stop` cannot interrupt them.
+ *
+ * @param {string} url - GitHub issue or PR URL (any normalization)
+ * @param {boolean} verbose - Whether to log verbose output
+ * @returns {{ sessionName: string, sessionId: string|null, sessionInfo: Object,
+ *   isolationBackend: string|null, stoppable: boolean }|null} Match or null
+ */
+export function findStoppableSessionByUrl(url, verbose = false) {
+  if (!url) return null;
+
+  const normalizedUrl = normalizeSessionUrl(url);
+
+  for (const [sessionName, sessionInfo] of activeSessions.entries()) {
+    if (!sessionInfo.url || normalizeSessionUrl(sessionInfo.url) !== normalizedUrl) {
+      continue;
+    }
+    // Issue #1586: skip expired non-isolation sessions — they are no longer running.
+    if (!sessionInfo.isolationBackend && !isNonIsolationSessionActive(sessionName, sessionInfo, verbose)) {
+      continue;
+    }
+
+    // The UUID `$ --stop` expects is the start-command session id. For
+    // isolation sessions it is tracked either as sessionInfo.sessionId or as
+    // the (UUID-shaped) session key itself.
+    const candidateId = sessionInfo.sessionId || sessionName;
+    const sessionId = SESSION_UUID_RE.test(candidateId) ? candidateId : null;
+    const stoppable = Boolean(sessionInfo.isolationBackend && sessionId);
+
+    if (verbose) {
+      const mode = sessionInfo.isolationBackend ? `isolation:${sessionInfo.isolationBackend}` : 'non-isolation';
+      console.log(`[VERBOSE] findStoppableSessionByUrl: matched ${sessionName} for ${url} (${mode}, stoppable=${stoppable})`);
+    }
+
+    return {
+      sessionName,
+      sessionId,
+      sessionInfo,
+      isolationBackend: sessionInfo.isolationBackend || null,
+      stoppable,
+    };
+  }
+
+  if (verbose) {
+    console.log(`[VERBOSE] findStoppableSessionByUrl: no tracked session for ${url}`);
+  }
+  return null;
+}
+
 /**
  * Async active-session check for command handlers.
  *

package/src/telegram-bot.mjs

@@ -43,7 +43,7 @@ const { isOldMessage: _isOldMessage, isGroupChat: _isGroupChat, isChatAuthorized
 const { installTelegramFormattingFallback, isTelegramFormattingError, isTelegramMessageTooLongError, safeEditMessageText, safeReply, TELEGRAM_TEXT_LIMIT } = await import('./telegram-safe-reply.lib.mjs');
 const { registerTerminalWatchCommand, startAutoTerminalWatchForSession } = await import('./telegram-terminal-watch-command.lib.mjs');
 const { launchBotWithRetry } = await import('./telegram-bot-launcher.lib.mjs');
-const { trackSession, startSessionMonitoring, hasActiveSessionForUrlAsync } = await import('./session-monitor.lib.mjs');
+const { trackSession, startSessionMonitoring, hasActiveSessionForUrlAsync, findStoppableSessionByUrl } = await import('./session-monitor.lib.mjs');
 const { formatExecutingWorkSessionMessage, formatStartingWorkSessionMessage } = await import('./work-session-formatting.lib.mjs');
 const { buildTelegramHelpMessage, buildTelegramInfoBlock, buildSolveQueuedMessage } = await import('./telegram-ui-messages.lib.mjs');
 
@@ -1068,7 +1068,7 @@ const { registerTopCommand } = await import('./telegram-top-command.lib.mjs');
 const { registerStartStopCommands } = await import('./telegram-start-stop-command.lib.mjs');
 const { registerLogCommand } = await import('./telegram-log-command.lib.mjs');
 registerTopCommand(bot, sharedCommandOpts);
-registerStartStopCommands(bot, { ...sharedCommandOpts, getSolveQueue });
+registerStartStopCommands(bot, { ...sharedCommandOpts, getSolveQueue, findRunningSessionByUrl: (url, verbose) => findStoppableSessionByUrl(url, verbose) });
 await registerLogCommand(bot, sharedCommandOpts);
 await registerTerminalWatchCommand(bot, sharedCommandOpts);
 

package/src/telegram-start-stop-command.lib.mjs

@@ -16,10 +16,15 @@
  * - `/stop <issue-or-pr-url>` (or reply to a message that contains one) looks
  *   the URL up in the in-memory solve queue and either cancels the queued
  *   item or forwards CTRL+C to the running isolated session (issue #1780).
+ * - `/stop <issue-or-pr-url>` also consults the session-monitor registry of
+ *   running detached sessions, so it can interrupt a task that started
+ *   immediately (queue empty) and was therefore never left in the queue's
+ *   `processing` Map — the case shown in issue #1871's screenshots.
  *
  * @see https://github.com/link-assistant/hive-mind/issues/1081
  * @see https://github.com/link-assistant/hive-mind/issues/524
  * @see https://github.com/link-assistant/hive-mind/issues/1780
+ * @see https://github.com/link-assistant/hive-mind/issues/1871
  * @see https://github.com/link-foundation/start/issues/112
  */
 
@@ -257,6 +262,12 @@ export function isStopTargetRequester({ userId, queueItem = null, sessionInfo =
  *   When omitted, the URL flow degrades gracefully to a "no queue available"
  *   message so unit tests for non-URL paths don't need to construct a queue.
  *   See https://github.com/link-assistant/hive-mind/issues/1780.
+ * @param {Function} [options.findRunningSessionByUrl] - Override for tests; looks
+ *   the URL up in the session-monitor registry of running detached sessions so
+ *   `/stop <url>` can interrupt tasks that started immediately (queue empty) and
+ *   were therefore never left in the queue's `processing` Map. When omitted, the
+ *   real `findStoppableSessionByUrl` from session-monitor is lazy-imported.
+ *   See https://github.com/link-assistant/hive-mind/issues/1871.
  */
 export function registerStartStopCommands(bot, options) {
   const { VERBOSE = false, isOldMessage, isForwardedOrReply, isGroupChat, isChatAuthorized, isTopicAuthorized, buildAuthErrorMessage, getSolveQueue } = options;
@@ -274,6 +285,26 @@ export function registerStartStopCommands(bot, options) {
     return mod.getTrackedSessionInfo(sessionId);
   }
 
+  // Issue #1871: look a URL up in the session-monitor registry of running
+  // detached sessions. A /solve or /codex that started immediately (queue
+  // empty) is dispatched straight to an isolation session and removed from the
+  // queue's `processing` Map, so the queue lookup alone reports "no task found"
+  // for a task that is clearly running. The session monitor still knows the
+  // URL → start-command-UUID mapping, which lets /stop <url> recover and
+  // interrupt the session. Test stubs can inject findRunningSessionByUrl.
+  async function lookupRunningSessionByUrl(url) {
+    try {
+      if (typeof options.findRunningSessionByUrl === 'function') {
+        return await options.findRunningSessionByUrl(url, VERBOSE);
+      }
+      const mod = await import('./session-monitor.lib.mjs');
+      return mod.findStoppableSessionByUrl(url, VERBOSE);
+    } catch (error) {
+      console.error('[ERROR] /stop: findStoppableSessionByUrl failed:', error);
+      return null;
+    }
+  }
+
   /**
    * Validate command context: checks old message, forwarded, group chat, authorized, and owner status.
    * @param {Object} ctx - Telegraf context
@@ -529,18 +560,42 @@ export function registerStartStopCommands(bot, options) {
       const url = target.value;
       VERBOSE && console.log(`[VERBOSE] /stop: detected URL ${url} (source=${target.source})`);
 
-      // Look up the queue item BEFORE auth so we can allow the original task
-      // requester to cancel their own task in a group (#1783). The lookup
-      // here does NOT mutate the queue — actual cancel happens below in
-      // resolveQueueLookupForUrl after auth has passed.
+      // Look up the queue item AND any running detached session BEFORE auth so
+      // we can allow the original task requester to cancel their own task in a
+      // group (#1783), regardless of whether the task is still queued or already
+      // dispatched to an isolation session (#1871). Neither lookup mutates
+      // state — actual cancel/stop happens below after auth has passed.
       const candidate = findQueueCandidateForUrl(url);
-      const ok = await authorizeTargetedStop(ctx, 'URL', { queueItem: candidate.item || null });
+      const runningSession = await lookupRunningSessionByUrl(url);
+      const ok = await authorizeTargetedStop(ctx, 'URL', { queueItem: candidate.item || null, sessionInfo: runningSession?.sessionInfo || null });
       if (!ok) return;
 
       const lookup = resolveQueueLookupForUrl(url);
       VERBOSE && console.log(`[VERBOSE] /stop: queue lookup for ${url} → ${lookup.action}`);
 
+      // Issue #1871: when the queue has no record of the task (it started
+      // immediately and was dispatched to a detached session) but the session
+      // monitor still tracks a running isolated session for this URL, forward
+      // CTRL+C to its start-command UUID. This is the common case for tasks
+      // that begin executing right away with `--isolation screen`.
+      const queueHasTask = lookup.action === 'cancel-queued' || lookup.action === 'stop-running';
+      if (!queueHasTask && runningSession?.stoppable && runningSession.sessionId) {
+        VERBOSE && console.log(`[VERBOSE] /stop: forwarding CTRL+C to tracked session ${runningSession.sessionId} for ${url} (queue action=${lookup.action})`);
+        await runStopIsolatedSessionFlow(ctx, runningSession.sessionId);
+        return;
+      }
+
       if (lookup.action === 'no-queue') {
+        // No solve queue in this context. If the session monitor found a
+        // running-but-non-stoppable (non-isolation) session, say so; otherwise
+        // fall back to the UUID hint.
+        if (runningSession) {
+          await ctx.reply(`⚠️ Found a running task for ${url}, but it was not started with an isolation backend, so \`/stop\` cannot forward CTRL+C to it.\n\nNext time you can run the command with \`--isolation screen\` to make this task interruptible via \`/stop\`.`, {
+            parse_mode: 'Markdown',
+            reply_to_message_id: message.message_id,
+          });
+          return;
+        }
         await ctx.reply(`ℹ️ Cannot look up tasks by URL right now (the bot has no solve queue available in this context).\n\nIf you have the session UUID, you can use \`/stop <UUID>\` instead.`, {
           parse_mode: 'Markdown',
           reply_to_message_id: message.message_id,
@@ -549,6 +604,16 @@ export function registerStartStopCommands(bot, options) {
       }
 
       if (lookup.action === 'not-found') {
+        // The session monitor also had no stoppable session (otherwise we would
+        // have forwarded CTRL+C above). If it tracked a non-isolation session,
+        // explain why it can't be stopped; otherwise report not found.
+        if (runningSession) {
+          await ctx.reply(`⚠️ Found a running task for ${url}, but it was not started with an isolation backend, so \`/stop\` cannot forward CTRL+C to it.\n\nNext time you can run the command with \`--isolation screen\` to make this task interruptible via \`/stop\`.`, {
+            parse_mode: 'Markdown',
+            reply_to_message_id: message.message_id,
+          });
+          return;
+        }
         await ctx.reply(`ℹ️ No queued or running task found for ${url}.\n\nIf the task is running with \`--isolation screen\`, try \`/stop <UUID>\` (the UUID is shown in the bot's session-id message).`, {
           parse_mode: 'Markdown',
           reply_to_message_id: message.message_id,