@link-assistant/hive-mind 1.69.5 → 1.69.7

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @link-assistant/hive-mind
 
+## 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
+
+- c2c51fa: Allow Telegram `/terminal_watch` and `/watch` to be used by the user who started a tracked session while preserving chat-owner access and private-repository DM routing.
+
 ## 1.69.5
 
 ### Patch Changes

package/package.json

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

package/src/locales/en.lino

@@ -175,10 +175,10 @@ en
   telegram.help_stop_start "*/stop* / */start* - Stop or resume accepting new tasks (owner only)"
   telegram.help_stop_uuid "*/stop* `<uuid>` - Send CTRL+C to an isolated solve/hive session (owner only). Also works as a reply to a message containing the UUID."
   telegram.help_log "*/log* - Fetch isolation session log (owner only). Usage: `/log <uuid>` or reply with `/log`"
-  telegram.help_terminal_watch "*/terminal\\_watch* - Live-update an isolation session log (owner only). Usage: `/terminal_watch <uuid>` or reply with `/terminal_watch`"
+  telegram.help_terminal_watch "*/terminal\\_watch* (alias: */watch*) - Live-update an isolation session log (chat owner or session requester). Usage: `/terminal_watch <uuid>`, `/watch <uuid>`, or reply with either command"
   telegram.help_notifications "🔔 *Session Notifications:* Completion notifications are automatic; use /subscribe for private DM forwards."
   telegram.help_isolation_mode "🔒 *Isolation Mode:* `{{isolationBackend}}` (experimental)"
-  telegram.help_group_note "⚠️ *Note:* /solve, /do, /continue, /claude, /codex, /opencode, /agent, /gemini, /qwen, /task, /split, /hive, /solve\\_queue, /limits, /version, /accept\\_invites, /merge, /stop and /start commands only work in group chats. /terminal\\_watch, /subscribe and /unsubscribe work in private and group chats."
+  telegram.help_group_note "⚠️ *Note:* /solve, /do, /continue, /claude, /codex, /opencode, /agent, /gemini, /qwen, /task, /split, /hive, /solve\\_queue, /limits, /version, /accept\\_invites, /merge, /stop and /start commands only work in group chats. /terminal\\_watch, /watch, /subscribe and /unsubscribe work in private and group chats."
   telegram.help_common_options "🔧 *Common Options:*"
   telegram.help_model_option "• `--model <model>` or `-m` - {{modelDescription}}"
   telegram.help_base_branch_option "• `--base-branch <branch>` or `-b` - Target branch for PR (default: repo default branch)"

package/src/locales/hi.lino

@@ -175,10 +175,10 @@ hi
   telegram.help_stop_start "*/stop* / */start* - नए tasks स्वीकार करना रोकें या फिर शुरू करें (केवल owner)"
   telegram.help_stop_uuid "*/stop* `<uuid>` - isolated solve/hive session को CTRL+C भेजें (केवल owner)। UUID वाले message पर reply के रूप में भी काम करता है।"
   telegram.help_log "*/log* - isolated session log लाएँ (केवल owner)। उपयोग: `/log <uuid>` या `/log` से reply करें"
-  telegram.help_terminal_watch "*/terminal\\_watch* - isolated session log को live-update करें (केवल owner)। उपयोग: `/terminal_watch <uuid>` या `/terminal_watch` से reply करें"
+  telegram.help_terminal_watch "*/terminal\\_watch* (alias: */watch*) - isolated session log को live-update करें (chat owner या session requester)। उपयोग: `/terminal_watch <uuid>`, `/watch <uuid>`, या इनमें से किसी command से reply करें"
   telegram.help_notifications "🔔 *Session Notifications:* completion notifications automatic हैं; private DM forwards के लिए /subscribe उपयोग करें।"
   telegram.help_isolation_mode "🔒 *Isolation Mode:* `{{isolationBackend}}` (experimental)"
-  telegram.help_group_note "⚠️ *नोट:* /solve, /do, /continue, /claude, /codex, /opencode, /agent, /gemini, /qwen, /task, /split, /hive, /solve\\_queue, /limits, /version, /accept\\_invites, /merge, /stop और /start commands केवल group chats में काम करती हैं। /terminal\\_watch, /subscribe और /unsubscribe private और group chats में काम करती हैं।"
+  telegram.help_group_note "⚠️ *नोट:* /solve, /do, /continue, /claude, /codex, /opencode, /agent, /gemini, /qwen, /task, /split, /hive, /solve\\_queue, /limits, /version, /accept\\_invites, /merge, /stop और /start commands केवल group chats में काम करती हैं। /terminal\\_watch, /watch, /subscribe और /unsubscribe private और group chats में काम करती हैं।"
   telegram.help_common_options "🔧 *Common Options:*"
   telegram.help_model_option "• `--model <model>` या `-m` - {{modelDescription}}"
   telegram.help_base_branch_option "• `--base-branch <branch>` या `-b` - PR के लिए target branch (default: repo default branch)"

package/src/locales/ru.lino

@@ -175,10 +175,10 @@ ru
   telegram.help_stop_start "*/stop* / */start* - Остановить или возобновить прием новых задач (только владелец)"
   telegram.help_stop_uuid "*/stop* `<uuid>` - Отправить CTRL+C в изолированный сеанс solve/hive (только владелец). Также работает ответом на сообщение с UUID."
   telegram.help_log "*/log* - Получить лог изолированного сеанса (только владелец). Использование: `/log <uuid>` или ответ `/log`"
-  telegram.help_terminal_watch "*/terminal\\_watch* - Обновлять лог изолированного сеанса вживую (только владелец). Использование: `/terminal_watch <uuid>` или ответ `/terminal_watch`"
+  telegram.help_terminal_watch "*/terminal\\_watch* (псевдоним: */watch*) - Обновлять лог изолированного сеанса вживую (владелец чата или пользователь, запустивший сеанс). Использование: `/terminal_watch <uuid>`, `/watch <uuid>` или ответ одной из этих команд"
   telegram.help_notifications "🔔 *Уведомления о сеансах:* Уведомления о завершении автоматические; используйте /subscribe для личных пересылок."
   telegram.help_isolation_mode "🔒 *Режим изоляции:* `{{isolationBackend}}` (экспериментально)"
-  telegram.help_group_note "⚠️ *Замечание:* команды /solve, /do, /continue, /claude, /codex, /opencode, /agent, /gemini, /qwen, /task, /split, /hive, /solve\\_queue, /limits, /version, /accept\\_invites, /merge, /stop и /start работают только в групповых чатах. /terminal\\_watch, /subscribe и /unsubscribe работают в личных и групповых чатах."
+  telegram.help_group_note "⚠️ *Замечание:* команды /solve, /do, /continue, /claude, /codex, /opencode, /agent, /gemini, /qwen, /task, /split, /hive, /solve\\_queue, /limits, /version, /accept\\_invites, /merge, /stop и /start работают только в групповых чатах. /terminal\\_watch, /watch, /subscribe и /unsubscribe работают в личных и групповых чатах."
   telegram.help_common_options "🔧 *Общие опции:*"
   telegram.help_model_option "• `--model <model>` или `-m` - {{modelDescription}}"
   telegram.help_base_branch_option "• `--base-branch <branch>` или `-b` - Целевая ветка для PR (по умолчанию ветка репозитория)"

package/src/locales/zh.lino

@@ -175,10 +175,10 @@ zh
   telegram.help_stop_start "*/stop* / */start* - 停止或恢复接收新任务（仅所有者）"
   telegram.help_stop_uuid "*/stop* `<uuid>` - 向隔离的 solve/hive 会话发送 CTRL+C（仅所有者）。也可回复包含 UUID 的消息。"
   telegram.help_log "*/log* - 获取隔离会话日志（仅所有者）。用法：`/log <uuid>` 或回复 `/log`"
-  telegram.help_terminal_watch "*/terminal\\_watch* - 实时更新隔离会话日志（仅所有者）。用法：`/terminal_watch <uuid>` 或回复 `/terminal_watch`"
+  telegram.help_terminal_watch "*/terminal\\_watch*（别名：*/watch*）- 实时更新隔离会话日志（聊天所有者或会话请求者）。用法：`/terminal_watch <uuid>`、`/watch <uuid>`，或用任一命令回复"
   telegram.help_notifications "🔔 *会话通知：* 完成通知会自动发送；使用 /subscribe 获取私聊转发。"
   telegram.help_isolation_mode "🔒 *隔离模式：* `{{isolationBackend}}`（实验性）"
-  telegram.help_group_note "⚠️ *注意：* /solve、/do、/continue、/claude、/codex、/opencode、/agent、/gemini、/qwen、/task、/split、/hive、/solve\\_queue、/limits、/version、/accept\\_invites、/merge、/stop 和 /start 仅在群聊中有效。/terminal\\_watch、/subscribe 和 /unsubscribe 在私聊和群聊中有效。"
+  telegram.help_group_note "⚠️ *注意：* /solve、/do、/continue、/claude、/codex、/opencode、/agent、/gemini、/qwen、/task、/split、/hive、/solve\\_queue、/limits、/version、/accept\\_invites、/merge、/stop 和 /start 仅在群聊中有效。/terminal\\_watch、/watch、/subscribe 和 /unsubscribe 在私聊和群聊中有效。"
   telegram.help_common_options "🔧 *常用选项：*"
   telegram.help_model_option "• `--model <model>` 或 `-m` - {{modelDescription}}"
   telegram.help_base_branch_option "• `--base-branch <branch>` 或 `-b` - PR 目标分支（默认：仓库默认分支）"

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,66 @@ 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 };
+}
+
 /**
  * Registers the /start and /stop command handlers with the bot
  * @param {Object} bot - The Telegraf bot instance
@@ -129,9 +197,13 @@ 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));
 
   /**
@@ -180,12 +252,146 @@ 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
+  /**
+   * Owner-only auth check for the /stop UUID and /stop URL flows. Mirrors the
+   * /log auth model: in private DMs the user is implicitly the owner; in
+   * groups they must be the chat creator. Replies with the appropriate error
+   * directly when auth fails.
+   *
+   * @param {Object} ctx - Telegraf context
+   * @param {string} label - Short human-readable label for the variant ('UUID', 'URL')
+   * @returns {Promise<boolean>} true when authorized
+   */
+  async function authorizeTargetedStop(ctx, label) {
+    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;
+      }
+    }
+    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`);
+        await ctx.reply(`❌ /stop <${label}> is only available to the chat owner.`, { 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 });
+    }
+  }
+
+  /**
+   * 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) {
+    if (typeof getSolveQueue !== 'function') {
+      return { action: 'no-queue' };
+    }
+    const queue = getSolveQueue({ verbose: VERBOSE });
+    const item = queue?.findByUrl?.(url);
+    if (!item) return { action: 'not-found' };
+
+    // 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 +399,76 @@ 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);
+    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})`);
+      const ok = await authorizeTargetedStop(ctx, 'UUID');
+      if (!ok) return;
+      await runStopIsolatedSessionFlow(ctx, sessionId);
+      return;
+    }
 
-    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;
-        }
+    if (target.kind === 'url') {
+      const url = target.value;
+      VERBOSE && console.log(`[VERBOSE] /stop: detected URL ${url} (source=${target.source})`);
+      const ok = await authorizeTargetedStop(ctx, 'URL');
+      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;
       }
 
-      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 <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` : '';
+        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;

package/src/telegram-terminal-watch-command.lib.mjs

@@ -17,7 +17,7 @@ const activeWatches = new Map();
 
 function splitCommandArgs(text) {
   const body = String(text || '')
-    .replace(/^\/terminal_watch(?:@\w+)?\b/i, '')
+    .replace(/^\/(?:terminal_watch|watch)(?:@\w+)?\b/i, '')
     .trim();
   return body.match(/"[^"]*"|'[^']*'|\S+/g)?.map(token => token.replace(/^(['"])(.*)\1$/, '$2')) || [];
 }
@@ -171,6 +171,12 @@ async function querySessionStatusWithRetry(querySessionStatus, sessionId, verbos
   return null;
 }
 
+export function isTerminalWatchSessionRequester({ sessionInfo = null, userId = null } = {}) {
+  if (userId === null || userId === undefined) return false;
+  if (sessionInfo?.requesterUserId === null || sessionInfo?.requesterUserId === undefined) return false;
+  return String(sessionInfo.requesterUserId) === String(userId);
+}
+
 // Note: /terminal_watch never uploads the full session log itself (issue #1720).
 // Use /log <uuid> if you want the log file delivered as a document.
 function getDisplayedTerminalSnapshot(logText, options) {
@@ -229,7 +235,7 @@ export function watchTerminalLogSession({ bot, chatId, messageId, sessionId, log
 }
 
 function buildUsage() {
-  return 'Usage:\n• `/terminal_watch <UUID>`\n• Reply to a session message with `/terminal_watch`\n\nOptions: `--size 120x25`, `--width 120`, `--height 25`, `--interval-ms 2500`, `--max-chars 3400`';
+  return 'Usage:\n• `/terminal_watch <UUID>` (alias: `/watch <UUID>`)\n• Reply to a session message with `/terminal_watch` or `/watch`\n\nOptions: `--size 120x25`, `--width 120`, `--height 25`, `--interval-ms 2500`, `--max-chars 3400`';
 }
 
 async function createWatchMessage({ ctx, targetChatId, replyToMessageId, text }) {
@@ -302,12 +308,14 @@ export async function startAutoTerminalWatchForSession({ bot, ctx, sessionId, se
 
 export async function registerTerminalWatchCommand(bot, options) {
   const { VERBOSE = false, isOldMessage, isChatAuthorized, isTopicAuthorized, buildAuthErrorMessage } = options;
-  const runner = await import('./isolation-runner.lib.mjs');
+  const runner = !options.querySessionStatus || !options.isTerminalSessionStatus ? await import('./isolation-runner.lib.mjs') : null;
+  const querySessionStatus = options.querySessionStatus || runner.querySessionStatus;
+  const isTerminalSessionStatus = options.isTerminalSessionStatus || runner.isTerminalSessionStatus;
   const getTrackedSessionInfo = options.getTrackedSessionInfo || (await import('./session-monitor.lib.mjs')).getTrackedSessionInfo;
   const detectRepositoryVisibility = options.detectRepositoryVisibility || (await import('./github.lib.mjs')).detectRepositoryVisibility;
   const parseGitHubUrl = options.parseGitHubUrl || (await import('./github.lib.mjs')).parseGitHubUrl;
 
-  bot.command('terminal_watch', async ctx => {
+  const handleTerminalWatchCommand = async ctx => {
     VERBOSE && console.log('[VERBOSE] /terminal_watch command received');
     if (isOldMessage && isOldMessage(ctx)) return;
 
@@ -327,17 +335,23 @@ export async function registerTerminalWatchCommand(bot, options) {
       return;
     }
 
+    const sessionInfo = getTrackedSessionInfo ? getTrackedSessionInfo(sessionId) : null;
+
     if (chat.type !== 'private') {
-      try {
-        const member = await ctx.telegram.getChatMember(chat.id, ctx.from.id);
-        if (!member || member.status !== 'creator') {
-          await ctx.reply('❌ /terminal_watch is only available to the chat owner.', { reply_to_message_id: message.message_id });
+      if (isTerminalWatchSessionRequester({ sessionInfo, userId: ctx.from?.id })) {
+        VERBOSE && console.log(`[VERBOSE] /terminal_watch allowed for session requester ${ctx.from?.id} on ${sessionId}`);
+      } else {
+        try {
+          const member = await ctx.telegram.getChatMember(chat.id, ctx.from.id);
+          if (!member || member.status !== 'creator') {
+            await ctx.reply('❌ /terminal_watch is only available to the chat owner or the user who started this session.', { reply_to_message_id: message.message_id });
+            return;
+          }
+        } catch (error) {
+          console.error('[ERROR] /terminal_watch: getChatMember failed:', error);
+          await ctx.reply('❌ Failed to verify permissions for /terminal_watch.', { reply_to_message_id: message.message_id });
           return;
         }
-      } catch (error) {
-        console.error('[ERROR] /terminal_watch: getChatMember failed:', error);
-        await ctx.reply('❌ Failed to verify permissions for /terminal_watch.', { reply_to_message_id: message.message_id });
-        return;
       }
     }
 
@@ -349,7 +363,7 @@ export async function registerTerminalWatchCommand(bot, options) {
 
     let statusResult;
     try {
-      statusResult = await runner.querySessionStatus(sessionId, VERBOSE);
+      statusResult = await querySessionStatus(sessionId, VERBOSE);
     } catch (error) {
       console.error('[ERROR] /terminal_watch: querySessionStatus failed:', error);
       await ctx.reply(`❌ Failed to query session status: ${error.message || String(error)}`, { reply_to_message_id: message.message_id });
@@ -361,7 +375,6 @@ export async function registerTerminalWatchCommand(bot, options) {
       return;
     }
 
-    const sessionInfo = getTrackedSessionInfo ? getTrackedSessionInfo(sessionId) : null;
     const { repoVisibility, repoDescription } = await resolveTerminalWatchRepository({ sessionInfo, statusResult, parseGitHubUrl, detectRepositoryVisibility });
     const decision = decideLogDestination({ statusResult, sessionInfo, repoVisibility, chatType: chat.type });
     if (decision.destination === 'reject') {
@@ -378,13 +391,16 @@ export async function registerTerminalWatchCommand(bot, options) {
     }
 
     try {
-      await startWatchFromResolvedSession({ bot, ctx, sessionId, statusResult, sessionInfo, decision, logPath, watchOptions: parsedArgs.options, querySessionStatus: runner.querySessionStatus, isTerminalSessionStatus: runner.isTerminalSessionStatus, repoDescription, verbose: VERBOSE });
+      await startWatchFromResolvedSession({ bot, ctx, sessionId, statusResult, sessionInfo, decision, logPath, watchOptions: parsedArgs.options, querySessionStatus, isTerminalSessionStatus, repoDescription, verbose: VERBOSE });
     } catch (error) {
       console.error('[ERROR] /terminal_watch: failed to start watch:', error);
       const friendly = error?.code === 403 || /chat not found|bot can't initiate conversation/i.test(error?.message || '') ? 'I could not send you a DM. Please open a private chat with me and send /start, then try again.' : `Failed to start terminal watch: ${error.message || String(error)}`;
       await ctx.reply(`❌ ${friendly}`, { reply_to_message_id: message.message_id });
     }
-  });
+  };
+
+  bot.command('terminal_watch', handleTerminalWatchCommand);
+  bot.command('watch', handleTerminalWatchCommand);
 }
 
 export const __INTERNAL_FOR_TESTS__ = {