@link-assistant/hive-mind 1.69.6 → 1.69.8

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @link-assistant/hive-mind
 
+## 1.69.8
+
+### Patch Changes
+
+- 175eaee: Fix two defects in the Telegram `/stop` command. (1) When `/stop` cancels a queued task by URL or reply, the original "⏳ Waiting (… queue #N)" card is now edited in place to show the task was cancelled (instead of leaving it stale). (2) Allow the user who originally ran `/solve` or `/hive` to `/stop` their own task by UUID or URL in a group chat, mirroring the requester authorization already used by `/terminal_watch` and `/watch` (PR #1779). The chat-creator fallback is preserved, so chat owners can still stop any task.
+
+## 1.69.7
+
+### Patch Changes
+
+- 2ea2bb7: Extend Telegram `/stop` to accept a GitHub issue or pull-request URL (passed as the argument or contained in the replied-to message). The bot looks the URL up in the in-memory solve queue and either cancels the queued item or forwards CTRL+C via `$ --stop <UUID>` to the running isolated session. The UUID flow from #524 and the chat-level pause flow from #1081 are preserved.
+
 ## 1.69.6
 
 ### Patch Changes

package/package.json

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

package/src/telegram-bot.mjs

@@ -1057,7 +1057,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);
+registerStartStopCommands(bot, { ...sharedCommandOpts, getSolveQueue });
 await registerLogCommand(bot, sharedCommandOpts);
 await registerTerminalWatchCommand(bot, sharedCommandOpts);
 

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

@@ -13,13 +13,21 @@
  * - `/stop <UUID>` or reply-to-message-with-UUID forwards CTRL+C to the
  *   matching isolated solve/hive session via `$ --stop <UUID>` from
  *   link-foundation/start (issue #524).
+ * - `/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).
  *
  * @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-foundation/start/issues/112
  */
 
 import { extractSessionIdFromText } from './telegram-log-command.lib.mjs';
+import { parseGitHubUrl } from './github.lib.mjs';
+import { cleanNonPrintableChars } from './telegram-markdown.lib.mjs';
+
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 
 // Store stopped chats: Map<chatId, { stoppedAt: Date, stoppedBy: { id, username, firstName }, reason?: string }>
 const stoppedChats = new Map();
@@ -117,6 +125,122 @@ export function extractStopSessionId(text, repliedTo) {
   return { sessionId: null, source: null };
 }
 
+/**
+ * Walk arbitrary text and return the first GitHub issue or pull-request URL
+ * found, or null. Tolerates multiple URLs (returns the first issue/pull URL
+ * in source order). Uses the same `parseGitHubUrl` validator as the rest of
+ * the bot so the result is always a normalized URL string.
+ *
+ * @param {string} text
+ * @returns {string|null}
+ */
+function findFirstIssueOrPullUrl(text) {
+  if (!text || typeof text !== 'string') return null;
+  const cleaned = cleanNonPrintableChars(text);
+  for (const word of cleaned.split(/\s+/)) {
+    if (!word) continue;
+    const parsed = parseGitHubUrl(word);
+    if (parsed.valid && (parsed.type === 'issue' || parsed.type === 'pull')) {
+      return parsed.normalized;
+    }
+  }
+  return null;
+}
+
+/**
+ * Extract the target of a `/stop` invocation. Returns the most specific
+ * target found among the four possible sources, in this priority order:
+ *
+ *   1. UUID in the `/stop` argument        (kind='uuid', source='argument')
+ *   2. UUID in the replied-to message      (kind='uuid', source='reply')
+ *   3. Issue/PR URL in the `/stop` argument (kind='url',  source='argument')
+ *   4. Issue/PR URL in the replied-to text  (kind='url',  source='reply')
+ *
+ * UUIDs win over URLs because UUIDs are globally unique whereas a single
+ * issue URL can map to several in-flight requests if the user enqueued the
+ * same issue twice. Argument wins over reply because the argument is the
+ * more deliberate signal (the user explicitly typed it).
+ *
+ * @param {string} text - Raw `/stop ...` command text
+ * @param {Object|null|undefined} repliedTo - Telegram message object being replied to
+ * @returns {{ kind: 'uuid'|'url'|null, value: string|null, source: 'argument'|'reply'|null }}
+ * @see https://github.com/link-assistant/hive-mind/issues/1780
+ */
+export function extractStopTarget(text, repliedTo) {
+  const argText = String(text || '').replace(/^\/stop(?:@\w+)?\s*/i, '');
+  const replyText = repliedTo ? `${repliedTo.text || ''}\n${repliedTo.caption || ''}` : '';
+
+  const argUuid = extractSessionIdFromText(argText);
+  if (argUuid) return { kind: 'uuid', value: argUuid, source: 'argument' };
+
+  const replyUuid = extractSessionIdFromText(replyText);
+  if (replyUuid) return { kind: 'uuid', value: replyUuid, source: 'reply' };
+
+  const argUrl = findFirstIssueOrPullUrl(argText);
+  if (argUrl) return { kind: 'url', value: argUrl, source: 'argument' };
+
+  const replyUrl = findFirstIssueOrPullUrl(replyText);
+  if (replyUrl) return { kind: 'url', value: replyUrl, source: 'reply' };
+
+  return { kind: null, value: null, source: null };
+}
+
+/**
+ * Update the queue card message in Telegram to show that the task was
+ * cancelled via /stop. Best-effort: silently swallows edit failures (e.g.,
+ * the card was already cleared by the consumer loop) — the dispatcher still
+ * sends its own ack reply, so the user always gets feedback.
+ *
+ * @param {Object} item - SolveQueueItem; reads .messageInfo and .ctx
+ * @param {string} url - GitHub issue/PR URL of the cancelled task
+ * @param {string|null} tool - Per-tool queue name (claude/agent/codex/...)
+ * @param {string} stopperName - Display name of the user who ran /stop
+ * @returns {Promise<boolean>} true when the card was edited
+ * @see https://github.com/link-assistant/hive-mind/issues/1783
+ */
+export async function updateQueueCardForCancellation(item, url, tool, stopperName) {
+  if (!item || !item.messageInfo || !item.ctx) return false;
+  const toolSuffix = tool ? ` from \`${tool}\` queue` : '';
+  const stopperSuffix = stopperName ? ` by ${stopperName}` : '';
+  const text = `🗑 *Cancelled*\n\n${url}\n\nRemoved${toolSuffix}${stopperSuffix} via /stop.`;
+  try {
+    const { chatId, messageId } = item.messageInfo;
+    await item.ctx.telegram.editMessageText(chatId, messageId, undefined, text, { parse_mode: 'Markdown' });
+    // Match the consumer's contract: once a card reaches a terminal state we
+    // forget the message coordinates so nothing else tries to edit it.
+    item.messageInfo = null;
+    return true;
+  } catch (error) {
+    console.error('[ERROR] /stop: failed to update queue card for cancellation:', error?.message || error);
+    return false;
+  }
+}
+
+/**
+ * Returns true when the user issuing /stop is the same user who originally
+ * requested the targeted task. Mirrors `isTerminalWatchSessionRequester` from
+ * /terminal_watch (PR #1779) so the two commands behave consistently.
+ *
+ * Accepts the requester either from a `SolveQueueItem` (URL flow) or from
+ * a tracked session info record (UUID flow).
+ *
+ * @param {Object} args
+ * @param {number|string|null|undefined} args.userId - ctx.from.id of the /stop sender
+ * @param {Object|null} [args.queueItem] - matched SolveQueueItem, if any
+ * @param {Object|null} [args.sessionInfo] - tracked session info, if any
+ * @returns {boolean}
+ * @see https://github.com/link-assistant/hive-mind/issues/1783
+ */
+export function isStopTargetRequester({ userId, queueItem = null, sessionInfo = null } = {}) {
+  if (userId === null || userId === undefined) return false;
+  const candidates = [queueItem?.requesterUserId, sessionInfo?.requesterUserId];
+  for (const candidate of candidates) {
+    if (candidate === null || candidate === undefined) continue;
+    if (String(candidate) === String(userId)) return true;
+  }
+  return false;
+}
+
 /**
  * Registers the /start and /stop command handlers with the bot
  * @param {Object} bot - The Telegraf bot instance
@@ -129,10 +253,26 @@ export function extractStopSessionId(text, repliedTo) {
  * @param {Function} [options.isTopicAuthorized] - Topic-level authorization fallback
  * @param {Function} [options.buildAuthErrorMessage] - Builds the chat-not-authorized message
  * @param {Function} [options.stopIsolatedSession] - Override for tests; calls `$ --stop <uuid>`
+ * @param {Function} [options.getSolveQueue] - Returns the in-memory SolveQueue (for `/stop <url>`).
+ *   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.
  */
 export function registerStartStopCommands(bot, options) {
-  const { VERBOSE = false, isOldMessage, isForwardedOrReply, isGroupChat, isChatAuthorized, isTopicAuthorized, buildAuthErrorMessage } = options;
+  const { VERBOSE = false, isOldMessage, isForwardedOrReply, isGroupChat, isChatAuthorized, isTopicAuthorized, buildAuthErrorMessage, getSolveQueue } = options;
   const stopIsolatedSessionImpl = options.stopIsolatedSession || (async (...args) => (await import('./isolation-runner.lib.mjs')).stopIsolatedSession(...args));
+  // Issue #1783: look the UUID up in the session monitor so /stop can let the
+  // user who started the task stop it (mirrors /terminal_watch from PR #1779).
+  // Test stubs can inject getTrackedSessionInfo directly via options.
+  // The real session-monitor.getTrackedSessionInfo is sync; we wrap it in an
+  // async tolerant helper so tests can pass either a sync or async stub.
+  async function lookupTrackedSessionInfo(sessionId) {
+    if (typeof options.getTrackedSessionInfo === 'function') {
+      return await options.getTrackedSessionInfo(sessionId);
+    }
+    const mod = await import('./session-monitor.lib.mjs');
+    return mod.getTrackedSessionInfo(sessionId);
+  }
 
   /**
    * Validate command context: checks old message, forwarded, group chat, authorized, and owner status.
@@ -180,12 +320,178 @@ export function registerStartStopCommands(bot, options) {
     return { valid: true, chatId };
   }
 
-  // /stop command. Two modes:
-  //   1. `/stop <UUID>` or reply-to-message-with-UUID — forward CTRL+C to the
-  //      matching isolated session via `$ --stop <UUID>` (issue #524).
-  //   2. bare `/stop` (optionally with a free-text reason) — pause new task
+  /**
+   * Authorization check for the /stop UUID and /stop URL flows.
+   *
+   * In private DMs the user is implicitly authorized. In group chats the user
+   * is authorized when EITHER:
+   *   - They are the chat creator, OR
+   *   - They are the original requester of the task being stopped (the user
+   *     who ran the /solve or /hive that produced the queue item / session).
+   *
+   * This mirrors /terminal_watch and /watch (PR #1779) which already let the
+   * task requester act on their own session without requiring chat-owner
+   * privileges. See https://github.com/link-assistant/hive-mind/issues/1783.
+   *
+   * @param {Object} ctx - Telegraf context
+   * @param {string} label - Short human-readable label for the variant ('UUID', 'URL')
+   * @param {Object} [opts]
+   * @param {Object|null} [opts.queueItem] - matched SolveQueueItem, if known
+   * @param {Object|null} [opts.sessionInfo] - tracked session info, if known
+   * @returns {Promise<boolean>} true when authorized
+   */
+  async function authorizeTargetedStop(ctx, label, { queueItem = null, sessionInfo = null } = {}) {
+    const message = ctx.message;
+    const chatId = ctx.chat?.id;
+    const chatType = ctx.chat?.type;
+    if (chatType === 'private') return true;
+    if (!isGroupChat(ctx)) {
+      await ctx.reply('❌ The /stop command only works in group chats or private chats with the bot.', { reply_to_message_id: message.message_id });
+      return false;
+    }
+    if (!isChatAuthorized(chatId)) {
+      if (!isTopicAuthorized || !isTopicAuthorized(ctx)) {
+        const errMsg = buildAuthErrorMessage ? buildAuthErrorMessage(ctx) : `❌ This chat (ID: ${chatId}) is not authorized to use this bot.`;
+        await ctx.reply(errMsg, { reply_to_message_id: message.message_id });
+        return false;
+      }
+    }
+
+    if (isStopTargetRequester({ userId: ctx.from?.id, queueItem, sessionInfo })) {
+      VERBOSE && console.log(`[VERBOSE] /stop <${label}> allowed for task requester ${ctx.from?.id}`);
+      return true;
+    }
+
+    try {
+      const member = await ctx.telegram.getChatMember(chatId, ctx.from.id);
+      if (!member || member.status !== 'creator') {
+        VERBOSE && console.log(`[VERBOSE] /stop <${label}> ignored: user is not chat owner or task requester`);
+        await ctx.reply(`❌ /stop <${label}> is only available to the chat owner or the user who started this task.`, { reply_to_message_id: message.message_id });
+        return false;
+      }
+    } catch (error) {
+      console.error(`[ERROR] /stop <${label}>: getChatMember failed:`, error);
+      await ctx.reply('❌ Failed to verify permissions for /stop.', { reply_to_message_id: message.message_id });
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * Forward CTRL+C to a running isolated session via `$ --stop <uuid>`.
+   * Posts an ack reply, edits it with the result. Used by both the
+   * `/stop <UUID>` path (issue #524) and the `/stop <url>` path when the
+   * matched queue item is already executing in an isolated session
+   * (issue #1780).
+   *
+   * @param {Object} ctx - Telegraf context
+   * @param {string} sessionId - UUID of the session to stop
+   */
+  async function runStopIsolatedSessionFlow(ctx, sessionId) {
+    const message = ctx.message;
+    const ack = await ctx.reply(`⏹️ Asking session \`${sessionId}\` to stop (sending CTRL+C via \`$ --stop\`)…`, {
+      parse_mode: 'Markdown',
+      reply_to_message_id: message.message_id,
+    });
+
+    let result;
+    try {
+      result = await stopIsolatedSessionImpl(sessionId, VERBOSE);
+    } catch (error) {
+      console.error('[ERROR] /stop: stopIsolatedSession threw:', error);
+      result = { success: false, output: '', error: error?.message || String(error) };
+    }
+
+    const trimmedOutput = (result.output || '').toString().trim();
+    const trimmedError = (result.error || '').toString().trim();
+    const lines = [];
+    if (result.success) {
+      lines.push(`✅ Stop request sent to session \`${sessionId}\`.`);
+      lines.push('');
+      lines.push('The session should terminate shortly.');
+      if (trimmedOutput) {
+        lines.push('');
+        lines.push('```');
+        lines.push(trimmedOutput.slice(0, 1000));
+        lines.push('```');
+      }
+    } else {
+      lines.push(`❌ Failed to stop session \`${sessionId}\`.`);
+      if (trimmedError) {
+        lines.push('');
+        lines.push('```');
+        lines.push(trimmedError.slice(0, 1000));
+        lines.push('```');
+      }
+    }
+
+    try {
+      await ctx.telegram.editMessageText(ack.chat.id, ack.message_id, undefined, lines.join('\n'), { parse_mode: 'Markdown' });
+    } catch (error) {
+      console.error('[ERROR] /stop: editMessageText failed, falling back to reply:', error);
+      await ctx.reply(lines.join('\n'), { parse_mode: 'Markdown', reply_to_message_id: message.message_id });
+    }
+  }
+
+  /**
+   * Find the candidate queue/processing item for a `/stop <url>` request
+   * without mutating queue state. Used by the dispatcher to look up the
+   * task's requesterUserId for authorization before any cancellation
+   * happens (#1783).
+   *
+   * @param {string} url - Normalized GitHub issue or PR URL
+   * @returns {{ action: 'no-queue'|'not-found'|'candidate', item?: Object, queue?: Object }}
+   */
+  function findQueueCandidateForUrl(url) {
+    if (typeof getSolveQueue !== 'function') {
+      return { action: 'no-queue' };
+    }
+    const queue = getSolveQueue({ verbose: VERBOSE });
+    const item = queue?.findByUrl?.(url);
+    if (!item) return { action: 'not-found' };
+    return { action: 'candidate', item, queue };
+  }
+
+  /**
+   * Resolve a `/stop <url>` request against the in-memory solve queue.
+   * Returns an action descriptor that the dispatcher executes.
+   *
+   * @param {string} url - Normalized GitHub issue or PR URL
+   * @returns {{ action: 'no-queue'|'not-found'|'cancel-queued'|'stop-running'|'running-not-isolated', item?: Object, sessionId?: string|null, tool?: string|null }}
+   */
+  function resolveQueueLookupForUrl(url) {
+    const candidate = findQueueCandidateForUrl(url);
+    if (candidate.action !== 'candidate') return candidate;
+    const { item, queue } = candidate;
+
+    // Queued items have a defined .id and live in one of the per-tool queues.
+    // The cancel(id) call walks every per-tool queue and returns true on hit.
+    const cancelled = queue.cancel(item.id);
+    if (cancelled) {
+      return { action: 'cancel-queued', item, tool: item.tool || null };
+    }
+
+    // Not in a per-tool queue → must be in `processing`. If it was started
+    // via an isolation backend, item.sessionName is the start-command UUID
+    // and we can forward CTRL+C to it. Non-isolated runs have a screen name
+    // that is not UUID-shaped — we can't safely interrupt those from here.
+    const sessionId = item.sessionName && UUID_RE.test(item.sessionName) ? item.sessionName : null;
+    if (sessionId) {
+      return { action: 'stop-running', item, sessionId, tool: item.tool || null };
+    }
+    return { action: 'running-not-isolated', item, tool: item.tool || null };
+  }
+
+  // /stop command. Three modes (checked in this order, before any reply
+  // rejection so the queue-card-reply ergonomics from issue #1780 work):
+  //   1. `/stop <UUID>` or reply with UUID — forward CTRL+C via
+  //      `$ --stop <UUID>` (issue #524).
+  //   2. `/stop <issue-or-pr-url>` or reply containing that URL — look up
+  //      the matching solve queue item; cancel it if queued, forward
+  //      CTRL+C if running with isolation (issue #1780).
+  //   3. bare `/stop` (optionally with a free-text reason) — pause new task
   //      acceptance for the chat (issue #1081).
-  // Only accessible by chat owner (creator) in both modes.
+  // Only accessible by chat owner (creator) in modes 1, 2 (in groups).
   bot.command('stop', async ctx => {
     VERBOSE && console.log('[VERBOSE] /stop command received');
     if (isOldMessage(ctx)) {
@@ -193,92 +499,100 @@ export function registerStartStopCommands(bot, options) {
       return;
     }
 
-    // Detect UUID modes BEFORE the forwarded/reply rejection used by the
-    // chat-level stop, because the UUID-from-reply mode is intentionally a
-    // reply (issue #524).
+    // Detect UUID/URL targets BEFORE the forwarded/reply rejection used by
+    // the chat-level stop, because both targeted modes are intentionally
+    // delivered as replies (issues #524, #1780).
     const message = ctx.message;
     const repliedTo = message?.reply_to_message || null;
-    const { sessionId, source } = extractStopSessionId(message?.text || '', repliedTo);
-
-    if (sessionId) {
-      VERBOSE && console.log(`[VERBOSE] /stop: detected UUID ${sessionId} (source=${source})`);
-      // Reuse the same auth model as /log: must be chat owner in groups; in
-      // private DMs the user is implicitly the owner of their own chat.
-      const chatId = ctx.chat?.id;
-      const chatType = ctx.chat?.type;
-      if (chatType !== 'private') {
-        if (!isGroupChat(ctx)) {
-          await ctx.reply('❌ The /stop command only works in group chats or private chats with the bot.', { reply_to_message_id: message.message_id });
-          return;
-        }
-        if (!isChatAuthorized(chatId)) {
-          if (!isTopicAuthorized || !isTopicAuthorized(ctx)) {
-            const errMsg = buildAuthErrorMessage ? buildAuthErrorMessage(ctx) : `❌ This chat (ID: ${chatId}) is not authorized to use this bot.`;
-            await ctx.reply(errMsg, { reply_to_message_id: message.message_id });
-            return;
-          }
-        }
-        try {
-          const member = await ctx.telegram.getChatMember(chatId, ctx.from.id);
-          if (!member || member.status !== 'creator') {
-            VERBOSE && console.log('[VERBOSE] /stop <UUID> ignored: user is not chat owner');
-            await ctx.reply('❌ /stop <UUID> is only available to the chat owner.', { reply_to_message_id: message.message_id });
-            return;
-          }
-        } catch (error) {
-          console.error('[ERROR] /stop <UUID>: getChatMember failed:', error);
-          await ctx.reply('❌ Failed to verify permissions for /stop.', { reply_to_message_id: message.message_id });
-          return;
-        }
+    const target = extractStopTarget(message?.text || '', repliedTo);
+
+    if (target.kind === 'uuid') {
+      const sessionId = target.value;
+      VERBOSE && console.log(`[VERBOSE] /stop: detected UUID ${sessionId} (source=${target.source})`);
+      // Look up the session's owner before auth so the original task requester
+      // can /stop their own session in a group even if they aren't the chat
+      // creator (#1783). Lookup failures are non-fatal: we fall through to the
+      // chat-owner-only check.
+      let sessionInfo = null;
+      try {
+        sessionInfo = await lookupTrackedSessionInfo(sessionId);
+      } catch (error) {
+        console.error('[ERROR] /stop: getTrackedSessionInfo failed:', error);
       }
+      const ok = await authorizeTargetedStop(ctx, 'UUID', { sessionInfo });
+      if (!ok) return;
+      await runStopIsolatedSessionFlow(ctx, sessionId);
+      return;
+    }
 
-      const ack = await ctx.reply(`⏹️ Asking session \`${sessionId}\` to stop (sending CTRL+C via \`$ --stop\`)…`, {
-        parse_mode: 'Markdown',
-        reply_to_message_id: message.message_id,
-      });
+    if (target.kind === 'url') {
+      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.
+      const candidate = findQueueCandidateForUrl(url);
+      const ok = await authorizeTargetedStop(ctx, 'URL', { queueItem: candidate.item || null });
+      if (!ok) return;
+
+      const lookup = resolveQueueLookupForUrl(url);
+      VERBOSE && console.log(`[VERBOSE] /stop: queue lookup for ${url} → ${lookup.action}`);
+
+      if (lookup.action === 'no-queue') {
+        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,
+        });
+        return;
+      }
 
-      let result;
-      try {
-        result = await stopIsolatedSessionImpl(sessionId, VERBOSE);
-      } catch (error) {
-        console.error('[ERROR] /stop <UUID>: stopIsolatedSession threw:', error);
-        result = { success: false, output: '', error: error?.message || String(error) };
+      if (lookup.action === 'not-found') {
+        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,
+        });
+        return;
       }
 
-      const trimmedOutput = (result.output || '').toString().trim();
-      const trimmedError = (result.error || '').toString().trim();
-      const lines = [];
-      if (result.success) {
-        lines.push(`✅ Stop request sent to session \`${sessionId}\`.`);
-        lines.push('');
-        lines.push('The session should terminate shortly.');
-        if (trimmedOutput) {
-          lines.push('');
-          lines.push('```');
-          lines.push(trimmedOutput.slice(0, 1000));
-          lines.push('```');
-        }
-      } else {
-        lines.push(`❌ Failed to stop session \`${sessionId}\`.`);
-        if (trimmedError) {
-          lines.push('');
-          lines.push('```');
-          lines.push(trimmedError.slice(0, 1000));
-          lines.push('```');
-        }
+      if (lookup.action === 'cancel-queued') {
+        VERBOSE && console.log(`[VERBOSE] /stop: cancelled queued item ${lookup.item?.id} for ${url}`);
+        const toolLabel = lookup.tool ? ` from \`${lookup.tool}\` queue` : '';
+
+        // Update the original queue card ("⏳ Waiting (claude queue #3)") to
+        // reflect that the task was cancelled. The queue stores the message
+        // coordinates on the item itself when the card was first posted —
+        // see telegram-bot.mjs where `item.messageInfo` is wired up.
+        const stopperName = ctx.from?.username ? `@${ctx.from.username}` : ctx.from?.first_name || `user ${ctx.from?.id}`;
+        await updateQueueCardForCancellation(lookup.item, url, lookup.tool, stopperName);
+
+        await ctx.reply(`🗑 Removed queued task for ${url}${toolLabel}.`, {
+          parse_mode: 'Markdown',
+          reply_to_message_id: message.message_id,
+        });
+        return;
       }
 
-      try {
-        await ctx.telegram.editMessageText(ack.chat.id, ack.message_id, undefined, lines.join('\n'), { parse_mode: 'Markdown' });
-      } catch (error) {
-        console.error('[ERROR] /stop <UUID>: editMessageText failed, falling back to reply:', error);
-        await ctx.reply(lines.join('\n'), { parse_mode: 'Markdown', reply_to_message_id: message.message_id });
+      if (lookup.action === 'stop-running') {
+        VERBOSE && console.log(`[VERBOSE] /stop: forwarding CTRL+C to running session ${lookup.sessionId} for ${url}`);
+        await runStopIsolatedSessionFlow(ctx, lookup.sessionId);
+        return;
       }
+
+      // running-not-isolated: a started, non-isolated screen session. We
+      // could shell out to `screen -X -S <name> stuff $'\003'`, but that's
+      // brittle and out of scope for #1780. Tell the user how to recover.
+      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;
     }
 
-    // No UUID — fall through to the chat-level pause flow. That flow rejects
-    // forwards/replies on purpose (#1081) so a stray reply doesn't pause the chat.
+    // No UUID or URL — fall through to the chat-level pause flow. That flow
+    // rejects forwards/replies on purpose (#1081) so a stray reply doesn't
+    // pause the chat.
     if (isForwardedOrReply(ctx)) {
       VERBOSE && console.log('[VERBOSE] /stop ignored: forwarded or reply');
       return;