@link-assistant/hive-mind 1.56.17 → 1.56.19

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @link-assistant/hive-mind
 
+## 1.56.19
+
+### Patch Changes
+
+- 0da8eba: Add a `/log` Telegram command that lets a chat owner pull the on-disk log of a `$` isolation session (`screen`, `tmux`, `docker`). The command accepts `/log <UUID>` directly or `/log` as a reply to any session message that contains a session UUID, validates the id with `$ --status`, derives the log path from start-command's `logPath` field, and uploads the file as a reply to the user. Logs from public GitHub repositories are uploaded to the same chat; logs from private (or unknown-visibility) repositories are sent via direct message after forwarding the originating session message into the DM, so private logs never leak into public chats. Access is restricted to the chat owner (Telegram `creator` status), matching the existing `/start`, `/stop`, and `/top` policy.
+
+## 1.56.18
+
+### Patch Changes
+
+- 47810ae: Telegram bot: add experimental `/subscribe` + `/unsubscribe` commands so users can opt in to receive a private DM forward of the `/solve` work-session completion message (commands work in both private and group chats; subscriptions are kept in memory and reset on bot restart). The completion message now includes both an `Issue:` line (the original URL passed to `/solve`) and, when the agent created a pull request for that issue, a follow-up `Pull request:` line so reviewers see both links without leaving the chat. (#1688)
+
 ## 1.56.17
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.56.17",
+  "version": "1.56.19",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",
@@ -15,7 +15,7 @@
     "hive-telegram-bot": "./src/telegram-bot.mjs"
   },
   "scripts": {
-    "test": "node tests/solve-queue.test.mjs && node tests/limits-display.test.mjs && node tests/test-usage-limit.mjs && node tests/test-codex-support.mjs && node tests/test-build-cost-info-string.mjs && node tests/test-claude-code-install-method.mjs && node tests/test-claude-quiet-config.mjs && node tests/test-configure-claude-bin.mjs && node tests/test-docker-release-order.mjs && node tests/test-docker-box-migration.mjs && node tests/test-hive-screens.mjs && node tests/test-issue-1616-pr-issue-link-preservation.mjs && node tests/test-pre-pr-failure-notifier-1640.mjs && node tests/test-ready-to-merge-pagination-1645.mjs && node tests/test-require-gh-paginate-rule.mjs && node tests/test-auto-restart-limits-1664.mjs && node tests/test-log-upload-output-1678.mjs && node tests/test-log-upload-output-1682.mjs && node tests/test-telegram-message-filters.mjs && node tests/test-telegram-bot-command-aliases.mjs && node tests/test-telegram-options-before-url.mjs && node tests/test-telegram-bot-configuration-isolation-links-notation.mjs && node tests/test-extract-isolation-from-args.mjs && node tests/test-solve-queue-command.mjs && node tests/test-queue-display-1267.mjs && node tests/test-issue-1670-screen-status-monitoring.mjs && node tests/test-issue-1680-session-monitoring.mjs && node tests/test-issue-1684-message-formatting.mjs && node tests/test-issue-1694-stabilized-defaults.mjs && node tests/test-telegram-bot-launcher.mjs",
+    "test": "node tests/solve-queue.test.mjs && node tests/limits-display.test.mjs && node tests/test-usage-limit.mjs && node tests/test-codex-support.mjs && node tests/test-build-cost-info-string.mjs && node tests/test-claude-code-install-method.mjs && node tests/test-claude-quiet-config.mjs && node tests/test-configure-claude-bin.mjs && node tests/test-docker-release-order.mjs && node tests/test-docker-box-migration.mjs && node tests/test-hive-screens.mjs && node tests/test-issue-1616-pr-issue-link-preservation.mjs && node tests/test-pre-pr-failure-notifier-1640.mjs && node tests/test-ready-to-merge-pagination-1645.mjs && node tests/test-require-gh-paginate-rule.mjs && node tests/test-auto-restart-limits-1664.mjs && node tests/test-log-upload-output-1678.mjs && node tests/test-log-upload-output-1682.mjs && node tests/test-telegram-message-filters.mjs && node tests/test-telegram-bot-command-aliases.mjs && node tests/test-telegram-options-before-url.mjs && node tests/test-telegram-bot-configuration-isolation-links-notation.mjs && node tests/test-extract-isolation-from-args.mjs && node tests/test-solve-queue-command.mjs && node tests/test-queue-display-1267.mjs && node tests/test-issue-1670-screen-status-monitoring.mjs && node tests/test-issue-1680-session-monitoring.mjs && node tests/test-issue-1684-message-formatting.mjs && node tests/test-issue-1686-log-command.mjs && node tests/test-issue-1688-subscribe-and-pr-link.mjs && node tests/test-issue-1694-stabilized-defaults.mjs && node tests/test-telegram-bot-launcher.mjs",
     "test:queue": "node tests/solve-queue.test.mjs",
     "test:limits-display": "node tests/limits-display.test.mjs",
     "test:usage-limit": "node tests/test-usage-limit.mjs",

package/src/isolation-runner.lib.mjs

@@ -41,17 +41,18 @@ export function generateSessionId() {
  * Keep the parser tolerant so completion monitoring survives either format.
  *
  * @param {string} output - Raw stdout from `$ --status`
- * @returns {{exists: boolean, uuid: string|null, status: string|null, exitCode: number|null, startTime: string|null, endTime: string|null, currentTime: string|null, raw: string}}
+ * @returns {{exists: boolean, uuid: string|null, status: string|null, exitCode: number|null, startTime: string|null, endTime: string|null, currentTime: string|null, logPath: string|null, command: string|null, isolation: string|null, workingDirectory: string|null, raw: string}}
  */
 export function parseSessionStatusOutput(output) {
   const raw = (output || '').trim();
   if (!raw) {
-    return { exists: false, uuid: null, status: null, exitCode: null, startTime: null, endTime: null, currentTime: null, raw: '' };
+    return { exists: false, uuid: null, status: null, exitCode: null, startTime: null, endTime: null, currentTime: null, logPath: null, command: null, isolation: null, workingDirectory: null, raw: '' };
   }
 
   try {
     const parsed = JSON.parse(raw);
     const data = Array.isArray(parsed) ? parsed[0] : parsed;
+    const isolationFromOptions = typeof data?.options?.isolation === 'string' ? data.options.isolation.toLowerCase() : null;
     return {
       exists: true,
       uuid: data?.uuid || null,
@@ -60,6 +61,10 @@ export function parseSessionStatusOutput(output) {
       startTime: data?.startTime || null,
       endTime: data?.endTime || null,
       currentTime: data?.currentTime || null,
+      logPath: data?.logPath || null,
+      command: data?.command || null,
+      isolation: typeof data?.isolation === 'string' ? data.isolation.toLowerCase() : isolationFromOptions,
+      workingDirectory: data?.workingDirectory || null,
       raw,
     };
   } catch {
@@ -87,6 +92,10 @@ export function parseSessionStatusOutput(output) {
     startTime: readField('startTime'),
     endTime: readField('endTime'),
     currentTime: readField('currentTime'),
+    logPath: readField('logPath'),
+    command: readField('command'),
+    isolation: readField('isolation')?.toLowerCase() || null,
+    workingDirectory: readField('workingDirectory'),
     raw,
   };
 }
@@ -213,7 +222,7 @@ export async function querySessionStatus(sessionId, verbose = false) {
     if (verbose) {
       console.log('[VERBOSE] isolation-runner: Cannot query status - $ binary not found');
     }
-    return { exists: false, uuid: null, status: null, exitCode: null, startTime: null, endTime: null, currentTime: null, raw: '' };
+    return { exists: false, uuid: null, status: null, exitCode: null, startTime: null, endTime: null, currentTime: null, logPath: null, command: null, isolation: null, workingDirectory: null, raw: '' };
   }
 
   try {
@@ -230,7 +239,7 @@ export async function querySessionStatus(sessionId, verbose = false) {
     if (verbose) {
       console.log(`[VERBOSE] isolation-runner: Status query error: ${error.message}`);
     }
-    return { exists: false, uuid: null, status: null, exitCode: null, startTime: null, endTime: null, currentTime: null, raw: '' };
+    return { exists: false, uuid: null, status: null, exitCode: null, startTime: null, endTime: null, currentTime: null, logPath: null, command: null, isolation: null, workingDirectory: null, raw: '' };
   }
 }
 

package/src/session-monitor.lib.mjs

@@ -18,6 +18,7 @@
 import { promisify } from 'util';
 import { exec as execCallback } from 'child_process';
 import { formatSessionCompletionMessage, getSessionCompletionExitCode } from './work-session-formatting.lib.mjs';
+import { notifySubscribers, getSubscriberCount } from './telegram-subscribers.lib.mjs';
 
 export { formatSessionCompletionMessage, getSessionCompletionExitCode } from './work-session-formatting.lib.mjs';
 
@@ -88,6 +89,21 @@ export function trackSession(sessionName, sessionInfo, verbose = false) {
   }
 }
 
+/**
+ * Look up the in-memory record for a session id (UUID for isolation sessions
+ * or the screen session name for non-isolation sessions). Returns null when no
+ * record exists — for example, after a process restart or for sessions that
+ * were never tracked through the Telegram bot. Used by `/log` to discover the
+ * originating chat id and the GitHub URL associated with a session.
+ *
+ * @param {string} sessionName
+ * @returns {Object|null}
+ */
+export function getTrackedSessionInfo(sessionName) {
+  if (!sessionName) return null;
+  return activeSessions.get(sessionName) || null;
+}
+
 /**
  * Get the number of active sessions being tracked
  * @param {boolean} verbose - Whether to log verbose output
@@ -251,6 +267,20 @@ export async function monitorSessions(bot, verbose = false, options = {}) {
 
       try {
         const finalExitCode = getSessionCompletionExitCode({ exitCode, statusResult });
+
+        // Issue #1688: When the original /solve URL was an issue, look up the
+        //   linked PR so the completion message can include both an `Issue:` and
+        //   a `Pull request:` line. Failures are logged and ignored — the
+        //   notification still goes out without the PR line.
+        let pullRequestUrl = null;
+        try {
+          pullRequestUrl = await resolvePullRequestUrlForSession(sessionInfo, { verbose, lookupLinkedPullRequest: options.lookupLinkedPullRequest });
+        } catch (lookupError) {
+          if (verbose) {
+            console.log(`[VERBOSE] Pull request lookup failed for ${sessionName}: ${lookupError?.message || lookupError}`);
+          }
+        }
+
         const message = formatSessionCompletionMessage({
           sessionName,
           sessionInfo,
@@ -258,13 +288,44 @@ export async function monitorSessions(bot, verbose = false, options = {}) {
           observedEndTime: new Date(),
           exitCode: finalExitCode,
           infoBlock: sessionInfo?.infoBlock || '',
+          pullRequestUrl,
         });
 
         // Update the original reply message if messageId is available, otherwise send new message
+        let notifyFromChatId = null;
+        let notifyMessageId = null;
         if (sessionInfo.messageId) {
           await bot.telegram.editMessageText(sessionInfo.chatId, sessionInfo.messageId, undefined, message, { parse_mode: 'Markdown' });
+          notifyFromChatId = sessionInfo.chatId;
+          notifyMessageId = sessionInfo.messageId;
         } else {
-          await bot.telegram.sendMessage(sessionInfo.chatId, message, { parse_mode: 'Markdown' });
+          const sent = await bot.telegram.sendMessage(sessionInfo.chatId, message, { parse_mode: 'Markdown' });
+          notifyFromChatId = sent?.chat?.id || sessionInfo.chatId;
+          notifyMessageId = sent?.message_id || null;
+        }
+
+        // Issue #1688: forward the same completion message to every /subscribe-d user
+        //   in their private chat with the bot. Failures are logged but don't block
+        //   completion of the parent session.
+        if (getSubscriberCount() > 0 && notifyFromChatId && notifyMessageId) {
+          try {
+            const skipUserIds = new Set();
+            if (sessionInfo?.requesterUserId) skipUserIds.add(sessionInfo.requesterUserId);
+            const summary = await notifySubscribers({
+              bot,
+              fromChatId: notifyFromChatId,
+              messageId: notifyMessageId,
+              fallbackText: message,
+              fallbackOptions: { parse_mode: 'Markdown' },
+              skipUserIds,
+              verbose,
+            });
+            if (verbose) {
+              console.log(`[VERBOSE] Subscribe notify summary for ${sessionName}: forwarded=${summary.forwarded}, sent=${summary.sent}, skipped=${summary.skipped}, failures=${summary.failures.length}`);
+            }
+          } catch (notifyError) {
+            console.error(`[session-monitor] notifySubscribers failed for ${sessionName}:`, notifyError);
+          }
         }
 
         completeSession(sessionName, finalExitCode || 0, verbose);
@@ -285,6 +346,51 @@ export async function monitorSessions(bot, verbose = false, options = {}) {
   }
 }
 
+/**
+ * Look up the URL of a pull request linked to the issue this session worked on.
+ * Returns null when the session was already operating on a PR, the URL context
+ * is missing, or no linked PR exists.
+ *
+ * Lazy-loads the GitHub batch helper so unrelated tests/imports don't pull
+ * GitHub deps. Tests can override the lookup via `options.lookupLinkedPullRequest`.
+ *
+ * @param {Object} sessionInfo
+ * @param {Object} [options]
+ * @param {boolean} [options.verbose]
+ * @param {Function} [options.lookupLinkedPullRequest] - Optional override `(ctx) => Promise<string|null>`
+ * @returns {Promise<string|null>} PR URL or null
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/1688
+ */
+async function resolvePullRequestUrlForSession(sessionInfo, { verbose = false, lookupLinkedPullRequest = null } = {}) {
+  const ctx = sessionInfo?.urlContext;
+  if (!ctx || ctx.type !== 'issue' || !ctx.owner || !ctx.repo || !ctx.number) {
+    return null;
+  }
+
+  if (typeof lookupLinkedPullRequest === 'function') {
+    return await lookupLinkedPullRequest(ctx);
+  }
+
+  try {
+    const { batchCheckPullRequestsForIssues } = await import('./github.lib.mjs');
+    const result = await batchCheckPullRequestsForIssues(ctx.owner, ctx.repo, [ctx.number]);
+    const linkedPRs = result?.[ctx.number]?.linkedPRs || [];
+    if (linkedPRs.length > 0 && linkedPRs[0].url) {
+      if (verbose) {
+        console.log(`[VERBOSE] Found linked PR ${linkedPRs[0].url} for issue ${ctx.owner}/${ctx.repo}#${ctx.number}`);
+      }
+      return linkedPRs[0].url;
+    }
+  } catch (error) {
+    if (verbose) {
+      console.log(`[VERBOSE] batchCheckPullRequestsForIssues failed for ${ctx.owner}/${ctx.repo}#${ctx.number}: ${error?.message || error}`);
+    }
+    throw error;
+  }
+  return null;
+}
+
 /**
  * Start the session monitoring interval
  * @param {Object} bot - Telegraf bot instance for sending messages

package/src/telegram-bot.mjs

@@ -551,7 +551,7 @@ async function safeReply(ctx, text, options = {}) {
   }
 }
 
-async function executeAndUpdateMessage(ctx, startingMessage, commandName, args, infoBlock, perCommandIsolation = null, tool = 'claude') {
+async function executeAndUpdateMessage(ctx, startingMessage, commandName, args, infoBlock, perCommandIsolation = null, tool = 'claude', urlContext = null) {
   const { chat, message_id: msgId } = startingMessage;
   const safeEdit = async text => {
     try {
@@ -560,22 +560,20 @@ async function executeAndUpdateMessage(ctx, startingMessage, commandName, args,
       console.error(`[telegram-bot] Failed to update message for ${commandName}: ${e.message}`);
     }
   };
+  const requesterUserId = ctx.from?.id ?? null; // Issue #1688: suppress duplicate /subscribe DM
   const iso = await resolveIsolation(perCommandIsolation, ISOLATION_BACKEND, isolationRunner, VERBOSE);
   let result, session;
   if (iso) {
     session = iso.runner.generateSessionId();
     VERBOSE && console.log(`[VERBOSE] Using isolation (${iso.backend}), session: ${session}`);
     result = await iso.runner.executeWithIsolation(commandName, args, { backend: iso.backend, sessionId: session, verbose: VERBOSE });
-    if (result.success) trackSession(session, { chatId: ctx.chat.id, messageId: msgId, startTime: new Date(), url: args[0], command: commandName, isolationBackend: iso.backend, sessionId: session, tool, infoBlock }, VERBOSE);
+    if (result.success) trackSession(session, { chatId: ctx.chat.id, messageId: msgId, startTime: new Date(), url: args[0], command: commandName, isolationBackend: iso.backend, sessionId: session, tool, infoBlock, urlContext, requesterUserId }, VERBOSE);
   } else {
     result = await executeStartScreen(commandName, args);
     const match = result.success && (result.output.match(/session:\s*(\S+)/i) || result.output.match(/screen -R\s+(\S+)/));
     session = match ? match[1] : 'unknown';
-    // Issue #1586: Track non-isolation sessions with timeout-based expiry.
-    // These sessions cannot reliably detect completion (screen stays alive via
-    // `exec bash`), so active URL checks auto-expire them after 10 min.
-    // This prevents accidental duplicate commands within the timeout window.
-    if (result.success && session !== 'unknown') trackSession(session, { chatId: ctx.chat.id, messageId: msgId, startTime: new Date(), url: args[0], command: commandName, tool, infoBlock }, VERBOSE);
+    // Issue #1586: Non-isolation sessions auto-expire after 10 min — screen stays alive via `exec bash` so completion can't be detected reliably; this still blocks duplicate commands in the timeout window.
+    if (result.success && session !== 'unknown') trackSession(session, { chatId: ctx.chat.id, messageId: msgId, startTime: new Date(), url: args[0], command: commandName, tool, infoBlock, urlContext, requesterUserId }, VERBOSE);
   }
   if (result.warning) return safeEdit(`⚠️  ${result.warning}`);
   if (result.success) {
@@ -662,13 +660,14 @@ bot.command('help', async ctx => {
   message += '*/merge* - Merge queue (experimental)\n';
   message += 'Usage: `/merge <github-repo-url>`\n';
   message += "Merges all PRs with 'ready' label sequentially.\n";
+  message += '*/subscribe* / */unsubscribe* - 🔔 Get private DM forward of /solve completion (experimental, #1688)\n';
   message += '*/help* - Show this help message\n';
-  message += '*/stop* - Stop accepting new tasks (owner only)\n';
-  message += '*/start* - Resume accepting tasks (owner only)\n\n';
-  message += '🔔 *Session Notifications:* The bot monitors sessions and notifies when they complete.\n';
+  message += '*/stop* / */start* - Stop or resume accepting new tasks (owner only)\n';
+  message += '*/log* - Fetch isolation session log (owner only). Usage: `/log <uuid>` or reply with `/log`\n\n';
+  message += '🔔 *Session Notifications:* Completion notifications are automatic; use /subscribe for private DM forwards.\n';
   if (ISOLATION_BACKEND) message += `🔒 *Isolation Mode:* \`${ISOLATION_BACKEND}\` (experimental)\n`;
   message += '\n';
-  message += '⚠️ *Note:* /solve, /do, /continue, /claude, /codex, /opencode, /agent, /hive, /solve\\_queue, /limits, /version, /accept\\_invites, /merge, /stop and /start commands only work in group chats.\n\n';
+  message += '⚠️ *Note:* /solve, /do, /continue, /claude, /codex, /opencode, /agent, /hive, /solve\\_queue, /limits, /version, /accept\\_invites, /merge, /stop and /start commands only work in group chats. /subscribe and /unsubscribe work in private and group chats.\n\n';
   message += '🔧 *Common Options:*\n';
   message += `• \`--model <model>\` or \`-m\` - ${buildModelOptionDescription()}\n`;
   message += '• `--base-branch <branch>` or `-b` - Target branch for PR (default: repo default branch)\n';
@@ -764,7 +763,6 @@ bot.command('version', async ctx => {
   await ctx.telegram.editMessageText(fetchingMessage.chat.id, fetchingMessage.message_id, undefined, '🤖 *Version Information*\n\n' + formatVersionMessage(result.versions), { parse_mode: 'Markdown' });
 });
 
-// Register external command modules (keeps telegram-bot.mjs under line limit)
 const { registerAcceptInvitesCommand } = await import('./telegram-accept-invitations.lib.mjs');
 const sharedCommandOpts = { VERBOSE, isOldMessage, isForwardedOrReply, isGroupChat: _isGroupChat, isChatAuthorized, isTopicAuthorized, buildAuthErrorMessage, addBreadcrumb, isChatStopped, getStoppedChatRejectMessage };
 registerAcceptInvitesCommand(bot, sharedCommandOpts);
@@ -772,6 +770,8 @@ const { registerMergeCommand } = await import('./telegram-merge-command.lib.mjs'
 registerMergeCommand(bot, sharedCommandOpts);
 const { registerSolveQueueCommand } = await import('./telegram-solve-queue-command.lib.mjs');
 const { handleSolveQueueCommand } = registerSolveQueueCommand(bot, { ...sharedCommandOpts, getSolveQueue });
+const { registerSubscribeCommands } = await import('./telegram-subscribers.lib.mjs'); // #1688
+registerSubscribeCommands(bot, sharedCommandOpts);
 
 // Named handler for /solve command - extracted for reuse by text-based fallback (issue #1207)
 async function handleSolveCommand(ctx) {
@@ -983,10 +983,10 @@ async function handleSolveCommand(ctx) {
   const normalizedUrl = validation.parsed.normalized;
 
   const requester = buildUserMention({ user: ctx.from, parseMode: 'Markdown' });
-  // Issue #1228: Show only user-provided options (exclude locked overrides to avoid duplication)
-  // Issue #1460: Escape options text to prevent Markdown parsing errors
+  // #1228: only user options; #1460: escape; #1688: 'Issue:' / 'Pull request:' label so completion can append PR link.
   const userOptionsRaw = userArgs.slice(1).join(' ');
-  let infoBlock = `Requested by: ${requester}\nURL: ${escapeMarkdown(normalizedUrl)}`;
+  const urlLabel = validation.parsed?.type === 'pull' ? 'Pull request' : 'Issue';
+  let infoBlock = `Requested by: ${requester}\n${urlLabel}: ${escapeMarkdown(normalizedUrl)}`;
   if (userOptionsRaw) infoBlock += `\n\n🛠 Options: ${escapeMarkdown(userOptionsRaw)}`;
   if (solveOverrides.length > 0) infoBlock += `${userOptionsRaw ? '\n' : '\n\n'}🔒 Locked options: ${escapeMarkdown(solveOverrides.join(' '))}`;
   const solveQueue = getSolveQueue({ verbose: VERBOSE });
@@ -1012,12 +1012,15 @@ async function handleSolveCommand(ctx) {
     return;
   }
 
+  // Issue #1688: parsed URL context lets the completion message look up linked PRs.
+  const solveUrlContext = validation.parsed ? { owner: validation.parsed.owner, repo: validation.parsed.repo, number: validation.parsed.number, type: validation.parsed.type, normalized: validation.parsed.normalized || normalizedUrl } : null;
+
   const toolQueuedCount = queueStats.queuedByTool[solveTool] || 0; // tool-specific queue count (#1551)
   if (check.canStart && toolQueuedCount === 0) {
     const startingMessage = await safeReply(ctx, formatStartingWorkSessionMessage({ infoBlock }), { reply_to_message_id: ctx.message.message_id });
-    await executeAndUpdateMessage(ctx, startingMessage, 'solve', args, infoBlock, effectiveSolveIsolation, solveTool);
+    await executeAndUpdateMessage(ctx, startingMessage, 'solve', args, infoBlock, effectiveSolveIsolation, solveTool, solveUrlContext);
   } else {
-    const queueItem = solveQueue.enqueue({ url: normalizedUrl, args, ctx, requester, infoBlock, tool: solveTool, perCommandIsolation: effectiveSolveIsolation });
+    const queueItem = solveQueue.enqueue({ url: normalizedUrl, args, ctx, requester, infoBlock, tool: solveTool, perCommandIsolation: effectiveSolveIsolation, urlContext: solveUrlContext });
     let queueMessage = `📋 Solve command queued (${solveTool} queue position #${toolQueuedCount + 1})\n\n${infoBlock}`; // tool-specific position (#1551)
     if (check.reason) queueMessage += `\n\n⏳ Waiting: ${escapeMarkdown(check.reason)}`;
     const queuedMessage = await safeReply(ctx, queueMessage, { reply_to_message_id: ctx.message.message_id });
@@ -1187,8 +1190,10 @@ bot.command(/^hive$/i, handleHiveCommand);
 
 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);
+await registerLogCommand(bot, sharedCommandOpts);
 
 // Add message listener for verbose debugging
 if (VERBOSE) {
@@ -1252,7 +1257,7 @@ bot.on('message', async (ctx, next) => {
     }
   }
 
-  // Check if this is a command we handle
+  // /subscribe + /unsubscribe (#1688) are intentionally not in the text fallback — Telegraf's bot.command() is sufficient.
   const solveHandlers = Object.fromEntries(SOLVE_COMMAND_NAMES.map(command => [command, handleSolveCommand]));
   const handlers = { ...solveHandlers, hive: handleHiveCommand, solve_queue: handleSolveQueueCommand, solvequeue: handleSolveQueueCommand };
 

package/src/telegram-isolation.lib.mjs

@@ -80,7 +80,27 @@ export function createIsolationAwareQueueCallback(botIsolationBackend, botIsolat
     if (iso) {
       const sid = iso.runner.generateSessionId();
       const r = await iso.runner.executeWithIsolation(item.command || 'solve', item.args, { backend: iso.backend, sessionId: sid, verbose });
-      if (r.success) trackSession(sid, { chatId: item.ctx?.chat?.id, messageId: item.messageInfo?.messageId, startTime: new Date(), url: item.url, command: item.command || 'solve', isolationBackend: iso.backend, sessionId: sid, tool: item.tool || 'claude', infoBlock: item.infoBlock }, verbose);
+      if (r.success)
+        trackSession(
+          sid,
+          {
+            chatId: item.ctx?.chat?.id,
+            messageId: item.messageInfo?.messageId,
+            startTime: new Date(),
+            url: item.url,
+            command: item.command || 'solve',
+            isolationBackend: iso.backend,
+            sessionId: sid,
+            tool: item.tool || 'claude',
+            infoBlock: item.infoBlock,
+            // Issue #1688: propagate URL context + requester through the queue so the
+            //   completion notification can append a 'Pull request:' line and skip
+            //   notifying the requester twice via /subscribe.
+            urlContext: item.urlContext || null,
+            requesterUserId: item.requesterUserId ?? null,
+          },
+          verbose
+        );
       return { ...r, sessionId: sid, isolationBackend: iso.backend, output: r.output || `session: ${sid}` };
     }
     return fallbackCallback(item);

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

@@ -0,0 +1,372 @@
+/**
+ * Telegram /log command implementation
+ *
+ * Lets a chat owner pull the log of an isolation session that was launched
+ * through the `$` (start-command) CLI. The session is identified by its UUID,
+ * either passed as `/log <UUID>` or extracted from a message that the
+ * `/log` command is replying to.
+ *
+ * Privacy guarantees:
+ * - Only the chat creator (`status === 'creator'`) may invoke `/log`.
+ * - Logs from public GitHub repositories may be uploaded into the chat where
+ *   `/log` was issued.
+ * - Logs from private GitHub repositories — and logs whose repository
+ *   visibility we cannot determine — are sent to the user via direct message
+ *   only, after forwarding the original message that contained the session id.
+ * - Currently only sessions launched with one of the `$` isolation backends
+ *   (`screen`, `tmux`, `docker`) are supported. Direct (non-isolation) sessions
+ *   are rejected with a clear message.
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/1686
+ */
+
+import path from 'path';
+import fs from 'fs/promises';
+import { constants as fsConstants } from 'fs';
+
+const UUID_RE = /\b([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\b/i;
+const ISOLATION_BACKENDS = new Set(['screen', 'tmux', 'docker']);
+// Telegram bots may upload documents up to 50 MB via sendDocument.
+// https://core.telegram.org/bots/api#senddocument
+const TELEGRAM_DOCUMENT_MAX_BYTES = 50 * 1024 * 1024;
+
+/**
+ * Extract the first RFC 4122 v4-shaped UUID found in `text`.
+ *
+ * @param {string|null|undefined} text
+ * @returns {string|null}
+ */
+export function extractSessionIdFromText(text) {
+  if (!text || typeof text !== 'string') return null;
+  const match = text.match(UUID_RE);
+  return match ? match[1].toLowerCase() : null;
+}
+
+/**
+ * Decide where the log for a session should be delivered.
+ *
+ * Inputs:
+ * - `statusResult`: parsed result of `$ --status <uuid>` (see
+ *   `parseSessionStatusOutput` in `isolation-runner.lib.mjs`).
+ * - `sessionInfo`: in-memory record from the Telegram session monitor, or null.
+ * - `repoVisibility`: result of `detectRepositoryVisibility(owner, repo)`, or
+ *   null when the repo could not be identified.
+ * - `chatType`: Telegram chat type where `/log` was invoked
+ *   (`'private'` | `'group'` | `'supergroup'` | `'channel'`).
+ *
+ * Output: `{ destination, reason, isolationBackend }` where `destination` is
+ * one of `'chat'` (deliver in the same chat), `'dm'` (deliver in DM),
+ * `'reject'` (don't deliver). `reason` is a short, user-facing string.
+ *
+ * @returns {{destination: 'chat'|'dm'|'reject', reason: string, isolationBackend: string|null}}
+ */
+export function decideLogDestination({ statusResult, sessionInfo, repoVisibility, chatType }) {
+  if (!statusResult || !statusResult.exists) {
+    return { destination: 'reject', reason: 'Unknown session id (start-command does not know about it).', isolationBackend: null };
+  }
+
+  // Determine isolation backend. Prefer the in-memory record (which knows what
+  // we asked `$` to use), fall back to whatever `$ --status` reports.
+  const isolationBackend = (sessionInfo?.isolationBackend || statusResult.isolation || '').toLowerCase() || null;
+  if (!isolationBackend || !ISOLATION_BACKENDS.has(isolationBackend)) {
+    return {
+      destination: 'reject',
+      reason: 'This command currently supports only sessions launched with `$` isolation (screen / tmux / docker).',
+      isolationBackend: isolationBackend || null,
+    };
+  }
+
+  // Privacy decision — fail closed when in doubt.
+  const isPublic = repoVisibility?.isPublic === true;
+  const visibilityKnown = !!repoVisibility && repoVisibility.visibility !== null;
+
+  if (isPublic && visibilityKnown) {
+    if (chatType === 'private') {
+      // /log was invoked in DM. Deliver in DM regardless of repo visibility.
+      return { destination: 'dm', reason: 'Public repository, delivering in DM (command was sent in a private chat).', isolationBackend };
+    }
+    return { destination: 'chat', reason: 'Public repository, delivering in chat.', isolationBackend };
+  }
+
+  // Private OR unknown visibility — never leak in a public chat.
+  return {
+    destination: 'dm',
+    reason: visibilityKnown ? 'Private repository — delivering via direct message.' : 'Repository visibility could not be determined — delivering via direct message (fail-closed).',
+    isolationBackend,
+  };
+}
+
+/**
+ * Resolve the on-disk log path for a session.
+ *
+ * Prefers the `logPath` field reported by `$ --status` (always correct when
+ * supported). Falls back to start-command's documented layout if the field is
+ * missing.
+ *
+ * @returns {string|null}
+ */
+export function resolveLogPath({ statusResult, isolationBackend }) {
+  if (statusResult?.logPath) return statusResult.logPath;
+  const uuid = statusResult?.uuid;
+  if (!uuid) return null;
+  if (isolationBackend && ISOLATION_BACKENDS.has(isolationBackend)) {
+    return path.join('/tmp/start-command/logs/isolation', isolationBackend, `${uuid}.log`);
+  }
+  return path.join('/tmp/start-command/logs/direct', `${uuid}.log`);
+}
+
+async function fileExists(filePath) {
+  try {
+    await fs.access(filePath, fsConstants.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function fileSize(filePath) {
+  try {
+    const stat = await fs.stat(filePath);
+    return stat.size;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Registers the /log command handler with the bot.
+ *
+ * Dependencies (`querySessionStatus`, `getTrackedSessionInfo`,
+ * `detectRepositoryVisibility`, `parseGitHubUrl`) are lazy-loaded from the
+ * existing libraries by default; tests pass mocked versions through `options`.
+ *
+ * @param {Object} bot - Telegraf bot instance
+ * @param {Object} options
+ * @param {boolean} [options.VERBOSE]
+ * @param {Function} options.isOldMessage
+ * @param {Function} options.isChatAuthorized
+ * @param {Function} [options.isTopicAuthorized]
+ * @param {Function} [options.buildAuthErrorMessage]
+ * @param {Function} [options.querySessionStatus] - Override for tests
+ * @param {Function} [options.getTrackedSessionInfo] - Override for tests
+ * @param {Function} [options.detectRepositoryVisibility] - Override for tests
+ * @param {Function} [options.parseGitHubUrl] - Override for tests
+ */
+export async function registerLogCommand(bot, options) {
+  const { VERBOSE = false, isOldMessage, isChatAuthorized, isTopicAuthorized, buildAuthErrorMessage } = options;
+  const querySessionStatus = options.querySessionStatus || (await import('./isolation-runner.lib.mjs')).querySessionStatus;
+  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('log', async ctx => {
+    VERBOSE && console.log('[VERBOSE] /log command received');
+
+    if (isOldMessage && isOldMessage(ctx)) {
+      VERBOSE && console.log('[VERBOSE] /log ignored: old message');
+      return;
+    }
+
+    const chat = ctx.chat;
+    const message = ctx.message;
+    if (!chat || !message) return;
+
+    const chatType = chat.type;
+    const chatId = chat.id;
+
+    // Extract the session id. Priority: explicit argument, then reply text.
+    const directSessionId = extractSessionIdFromText(message.text || '');
+    const repliedTo = message.reply_to_message;
+    const replySessionId = repliedTo ? extractSessionIdFromText(repliedTo.text || repliedTo.caption || '') : null;
+    const sessionId = directSessionId || replySessionId;
+
+    if (!sessionId) {
+      await ctx.reply('❌ /log requires a session id.\n\nUsage:\n• `/log <UUID>` — fetch a specific session log\n• Reply to a session message with `/log` — fetch the session referenced in that message', {
+        parse_mode: 'Markdown',
+        reply_to_message_id: message.message_id,
+      });
+      return;
+    }
+
+    // Authorization. /log is only available to chat owners. In private chats
+    // there is no "creator" status — the user is implicitly the owner of their
+    // own DM, so we allow it. We still apply the optional allowlist used by
+    // other commands so a private bot deployment can lock /log to known users.
+    if (chatType === 'private') {
+      // No further auth required beyond the optional whitelist applied below.
+    } else {
+      try {
+        const member = await ctx.telegram.getChatMember(chatId, ctx.from.id);
+        if (!member || member.status !== 'creator') {
+          VERBOSE && console.log('[VERBOSE] /log rejected: not chat owner');
+          await ctx.reply('❌ /log is only available to the chat owner.', { reply_to_message_id: message.message_id });
+          return;
+        }
+      } catch (error) {
+        console.error('[ERROR] /log: getChatMember failed:', error);
+        await ctx.reply('❌ Failed to verify permissions for /log.', { reply_to_message_id: message.message_id });
+        return;
+      }
+    }
+
+    if (isChatAuthorized && !isChatAuthorized(chatId)) {
+      // Topic-aware fallback (used elsewhere in this repo for forum topics).
+      if (!isTopicAuthorized || !isTopicAuthorized(ctx)) {
+        VERBOSE && console.log('[VERBOSE] /log rejected: chat not authorized');
+        const errMsg = buildAuthErrorMessage ? buildAuthErrorMessage(ctx) : `❌ This chat (ID: ${chatId}) is not authorized.`;
+        await ctx.reply(errMsg, { reply_to_message_id: message.message_id });
+        return;
+      }
+    }
+
+    // 1. Validate the session id with $ --status.
+    let statusResult;
+    try {
+      statusResult = await querySessionStatus(sessionId, VERBOSE);
+    } catch (error) {
+      console.error('[ERROR] /log: querySessionStatus failed:', error);
+      await ctx.reply(`❌ Failed to query session status: ${error.message || String(error)}`, { reply_to_message_id: message.message_id });
+      return;
+    }
+
+    if (!statusResult || !statusResult.exists) {
+      await ctx.reply(`❌ Session \`${sessionId}\` is not known to start-command.\n\nUse the session id from a \`📊 Session: <uuid>\` line in one of the bot's status messages.`, {
+        parse_mode: 'Markdown',
+        reply_to_message_id: message.message_id,
+      });
+      return;
+    }
+
+    // 2. Look up tracked metadata (for repo URL and original chat).
+    const sessionInfo = getTrackedSessionInfo ? getTrackedSessionInfo(sessionId) : null;
+
+    // 3. Decide repo visibility — prefer the URL we tracked at launch time.
+    let repoVisibility = null;
+    let repoUrlDescription = null;
+    const trackedUrl = sessionInfo?.url || null;
+    if (trackedUrl) {
+      const parsed = parseGitHubUrl ? parseGitHubUrl(trackedUrl) : null;
+      if (parsed && parsed.valid && parsed.owner && parsed.repo) {
+        repoUrlDescription = `${parsed.owner}/${parsed.repo}`;
+        try {
+          repoVisibility = await detectRepositoryVisibility(parsed.owner, parsed.repo);
+        } catch (error) {
+          console.error('[ERROR] /log: detectRepositoryVisibility failed:', error);
+          repoVisibility = null;
+        }
+      }
+    }
+
+    // 4. Decide the destination.
+    const decision = decideLogDestination({ statusResult, sessionInfo, repoVisibility, chatType });
+    if (decision.destination === 'reject') {
+      await ctx.reply(`❌ ${decision.reason}`, { reply_to_message_id: message.message_id });
+      return;
+    }
+
+    // 5. Resolve and validate the on-disk log file.
+    const logPath = resolveLogPath({ statusResult, isolationBackend: decision.isolationBackend });
+    if (!logPath) {
+      await ctx.reply('❌ Could not determine the log file path for this session.', { reply_to_message_id: message.message_id });
+      return;
+    }
+    if (!(await fileExists(logPath))) {
+      await ctx.reply(`❌ Log file does not exist on disk:\n\`${logPath}\`\n\nThe session may have been cleaned up by the host or the isolation backend.`, {
+        parse_mode: 'Markdown',
+        reply_to_message_id: message.message_id,
+      });
+      return;
+    }
+    const size = await fileSize(logPath);
+    if (size !== null && size > TELEGRAM_DOCUMENT_MAX_BYTES) {
+      await ctx.reply(`❌ Log file is ${(size / (1024 * 1024)).toFixed(1)} MB which exceeds Telegram's 50 MB document upload limit.\n\nFile path on host: \`${logPath}\``, {
+        parse_mode: 'Markdown',
+        reply_to_message_id: message.message_id,
+      });
+      return;
+    }
+
+    const filename = path.basename(logPath);
+    const captionLines = [`📁 Log for session \`${sessionId}\``];
+    if (decision.isolationBackend) captionLines.push(`🔒 Isolation: \`${decision.isolationBackend}\``);
+    if (statusResult.status) captionLines.push(`Status: \`${statusResult.status}\``);
+    if (repoUrlDescription) captionLines.push(`Repo: \`${repoUrlDescription}\``);
+    captionLines.push(`Privacy: ${decision.reason}`);
+    const caption = captionLines.join('\n');
+
+    if (decision.destination === 'chat') {
+      // Public repository → reply with the document directly in the chat.
+      try {
+        await ctx.replyWithDocument({ source: logPath, filename }, { reply_to_message_id: message.message_id, caption, parse_mode: 'Markdown' });
+      } catch (error) {
+        console.error('[ERROR] /log: replyWithDocument failed:', error);
+        await ctx.reply(`❌ Failed to upload log: ${error.message || String(error)}`, { reply_to_message_id: message.message_id });
+      }
+      return;
+    }
+
+    // DM flow: forward the originating message into DM (so the audit chain
+    // is preserved), then reply to that forwarded message with the log file.
+    const userId = ctx.from?.id;
+    if (!userId) {
+      await ctx.reply('❌ Cannot deliver the log via DM: missing user id.', { reply_to_message_id: message.message_id });
+      return;
+    }
+
+    let forwardedMessageId = null;
+    try {
+      // Forward the message that contains the session id (the reply target if
+      // any, otherwise the /log message itself).
+      const forwardSource = repliedTo || message;
+      const forwardedFromChatId = forwardSource === repliedTo ? chatId : chatId;
+      const forwardedSourceMessageId = forwardSource.message_id;
+      try {
+        const forwarded = await ctx.telegram.forwardMessage(userId, forwardedFromChatId, forwardedSourceMessageId);
+        forwardedMessageId = forwarded?.message_id || null;
+      } catch (forwardError) {
+        // forwardMessage can fail if the user has not opened a DM with the bot
+        // yet, or the source chat blocks forwards. Fall back to copyMessage,
+        // which works without a forward header.
+        try {
+          const copied = await ctx.telegram.copyMessage(userId, forwardedFromChatId, forwardedSourceMessageId);
+          forwardedMessageId = copied?.message_id || null;
+        } catch (copyError) {
+          console.error('[ERROR] /log: forward/copyMessage to DM failed:', forwardError, copyError);
+          // Fall through — we can still try sendDocument without a reply ref.
+        }
+      }
+    } catch (error) {
+      console.error('[ERROR] /log: DM forwarding step failed:', error);
+    }
+
+    try {
+      const replyOpts = forwardedMessageId ? { reply_to_message_id: forwardedMessageId, caption, parse_mode: 'Markdown' } : { caption, parse_mode: 'Markdown' };
+      await ctx.telegram.sendDocument(userId, { source: logPath, filename }, replyOpts);
+    } catch (error) {
+      console.error('[ERROR] /log: sendDocument to DM failed:', error);
+      // Tell the user, in their original chat, that DM delivery failed
+      // (commonly because they have not started a chat with the bot).
+      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 send the log via DM: ${error.message || String(error)}`;
+      await ctx.reply(`❌ ${friendly}`, { reply_to_message_id: message.message_id });
+      return;
+    }
+
+    // Acknowledge in the original chat (only if it wasn't already a DM).
+    if (chatType !== 'private') {
+      try {
+        await ctx.reply(`📬 Sent the log for \`${sessionId}\` to your direct messages (private repository).`, {
+          parse_mode: 'Markdown',
+          reply_to_message_id: message.message_id,
+        });
+      } catch (error) {
+        console.error('[ERROR] /log: failed to acknowledge in chat:', error);
+      }
+    }
+  });
+}
+
+export const __INTERNAL_FOR_TESTS__ = {
+  UUID_RE,
+  TELEGRAM_DOCUMENT_MAX_BYTES,
+  ISOLATION_BACKENDS,
+};

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

@@ -43,6 +43,11 @@ class SolveQueueItem {
     this.requester = options.requester;
     this.infoBlock = options.infoBlock;
     this.tool = options.tool || 'claude';
+    // Issue #1688: keep parsed URL context (owner/repo/number/type) so completion
+    //   notifications can look up linked PRs for issue URLs.
+    this.urlContext = options.urlContext || null;
+    // Issue #1688: requester user ID for /subscribe duplicate-suppression.
+    this.requesterUserId = options.ctx?.from?.id ?? null;
     this.createdAt = new Date();
     this.startedAt = null;
     this.status = QueueItemStatus.QUEUED;
@@ -1361,7 +1366,20 @@ export function createQueueExecuteCallback(executeStartScreen, trackSessionFn) {
       const match = result.output && (result.output.match(/session:\s*(\S+)/i) || result.output.match(/screen -R\s+(\S+)/));
       const session = match ? match[1] : null;
       if (session) {
-        trackSessionFn(session, { chatId: item.ctx?.chat?.id, messageId: item.messageInfo?.messageId, startTime: new Date(), url: item.url, command: 'solve', tool: item.tool || 'claude', infoBlock: item.infoBlock });
+        trackSessionFn(session, {
+          chatId: item.ctx?.chat?.id,
+          messageId: item.messageInfo?.messageId,
+          startTime: new Date(),
+          url: item.url,
+          command: 'solve',
+          tool: item.tool || 'claude',
+          infoBlock: item.infoBlock,
+          // Issue #1688: propagate URL context + requester so the completion
+          //   notification can append a 'Pull request:' line and skip
+          //   notifying the requester twice via /subscribe.
+          urlContext: item.urlContext || null,
+          requesterUserId: item.requesterUserId ?? null,
+        });
       }
     }
     return result;

package/src/telegram-subscribers.lib.mjs

@@ -0,0 +1,220 @@
+/**
+ * Telegram /subscribe and /unsubscribe command implementation (experimental).
+ *
+ * In-memory store of users who want to receive a private notification when
+ * a /solve (or alias) work session completes. Storage is intentionally
+ * volatile: subscriptions are cleared on bot restart since we do not yet
+ * have a database (issue #1688).
+ *
+ * /subscribe and /unsubscribe work in both private chats and public group
+ * chats. They store the Telegram user ID (not the chat ID) so a single
+ * user only ever receives one private notification, regardless of which
+ * chat they ran the command in.
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/1688
+ */
+
+// Map<userId, { username, firstName, subscribedAt, sourceChatId }>
+const subscribers = new Map();
+
+export function isSubscribed(userId) {
+  if (userId === null || userId === undefined) return false;
+  return subscribers.has(userId);
+}
+
+export function addSubscriber(userId, info = {}) {
+  if (userId === null || userId === undefined) return false;
+  const existed = subscribers.has(userId);
+  subscribers.set(userId, {
+    username: info.username || null,
+    firstName: info.firstName || null,
+    subscribedAt: existed ? subscribers.get(userId).subscribedAt : new Date(),
+    sourceChatId: info.sourceChatId ?? null,
+  });
+  return !existed;
+}
+
+export function removeSubscriber(userId) {
+  if (userId === null || userId === undefined) return false;
+  return subscribers.delete(userId);
+}
+
+export function getSubscribers() {
+  return Array.from(subscribers.entries()).map(([userId, info]) => ({ userId, ...info }));
+}
+
+export function getSubscriberCount() {
+  return subscribers.size;
+}
+
+export function resetSubscribersForTests() {
+  subscribers.clear();
+}
+
+/**
+ * Forward (or send) a session-completion notification to every subscribed user
+ * in their private chat with the bot.
+ *
+ * Strategy:
+ *   1. Try forwardMessage(userId, sourceChatId, messageId) — preserves the
+ *      original visual style of the reply Telegram users already see in chat.
+ *   2. If that fails (e.g. the user has never started a private chat with
+ *      the bot, or the message can't be forwarded), fall back to
+ *      sendMessage(userId, fallbackText) so the notification still arrives
+ *      when possible.
+ *
+ * Returns a summary so callers can log delivery results.
+ *
+ * @param {Object} params
+ * @param {Object} params.bot - Telegraf bot instance
+ * @param {number} params.fromChatId - Chat ID of the original /solve reply
+ * @param {number} params.messageId - Message ID of the (now-edited) reply
+ * @param {string} [params.fallbackText] - Plain-text body to send when forwardMessage is rejected
+ * @param {Object} [params.fallbackOptions] - Telegram sendMessage options for fallback
+ * @param {Set<number>} [params.skipUserIds] - Users that should not receive the notification (e.g. requester is already in the chat)
+ * @param {boolean} [params.verbose]
+ * @returns {Promise<{forwarded: number, sent: number, skipped: number, failures: Array}>}
+ */
+export async function notifySubscribers({ bot, fromChatId, messageId, fallbackText = '', fallbackOptions = {}, skipUserIds = null, verbose = false } = {}) {
+  const summary = { forwarded: 0, sent: 0, skipped: 0, failures: [] };
+  if (!bot || !bot.telegram) {
+    if (verbose) console.log('[VERBOSE] notifySubscribers: missing bot/telegram, skipping');
+    return summary;
+  }
+
+  for (const [userId, info] of subscribers.entries()) {
+    if (skipUserIds && skipUserIds.has(userId)) {
+      summary.skipped += 1;
+      if (verbose) console.log(`[VERBOSE] notifySubscribers: skipping user ${userId} (in skip set)`);
+      continue;
+    }
+
+    let forwarded = false;
+    if (fromChatId !== null && fromChatId !== undefined && messageId !== null && messageId !== undefined) {
+      try {
+        await bot.telegram.forwardMessage(userId, fromChatId, messageId);
+        summary.forwarded += 1;
+        forwarded = true;
+        if (verbose) {
+          console.log(`[VERBOSE] notifySubscribers: forwarded to user ${userId} (${info.username || info.firstName || 'unknown'})`);
+        }
+      } catch (error) {
+        if (verbose) {
+          console.log(`[VERBOSE] notifySubscribers: forwardMessage to ${userId} failed: ${error?.message || error}`);
+        }
+      }
+    }
+
+    if (forwarded) continue;
+
+    if (!fallbackText) {
+      summary.failures.push({ userId, reason: 'forwardMessage failed and no fallback text supplied' });
+      continue;
+    }
+
+    try {
+      await bot.telegram.sendMessage(userId, fallbackText, fallbackOptions);
+      summary.sent += 1;
+      if (verbose) {
+        console.log(`[VERBOSE] notifySubscribers: sent fallback message to user ${userId}`);
+      }
+    } catch (error) {
+      summary.failures.push({ userId, reason: error?.message || String(error) });
+      if (verbose) {
+        console.log(`[VERBOSE] notifySubscribers: sendMessage to ${userId} failed: ${error?.message || error}`);
+      }
+    }
+  }
+
+  return summary;
+}
+
+const SUBSCRIBE_CONFIRMATION = '🔔 *Subscribed* (experimental)\n\n' + 'You will receive a private notification each time a /solve command finishes (in any chat where this bot runs).\n\n' + '⚠️ Subscriptions are kept in memory and are cleared whenever the bot restarts.\n\n' + '💡 If notifications never arrive, open a private chat with the bot and send /start so Telegram lets the bot DM you.\n\n' + 'Use /unsubscribe to stop receiving these notifications.';
+
+const UNSUBSCRIBE_CONFIRMATION = '🔕 *Unsubscribed*\n\n' + 'You will no longer receive private notifications when /solve commands finish.\n\n' + 'Use /subscribe to resume notifications.';
+
+const NOT_SUBSCRIBED_MESSAGE = 'ℹ️ You are not subscribed.\n\nUse /subscribe to start receiving private notifications when /solve commands finish.';
+
+/**
+ * Register /subscribe and /unsubscribe handlers.
+ *
+ * @param {Object} bot - Telegraf bot instance
+ * @param {Object} options - Shared command options (VERBOSE, isOldMessage, ...)
+ */
+export function registerSubscribeCommands(bot, options = {}) {
+  const { VERBOSE = false, isOldMessage, isForwardedOrReply, isTopicAuthorized, buildAuthErrorMessage, addBreadcrumb } = options;
+
+  async function shouldHandle(ctx, cmdName) {
+    VERBOSE && console.log(`[VERBOSE] ${cmdName} command received`);
+    if (addBreadcrumb) {
+      await addBreadcrumb({
+        category: 'telegram.command',
+        message: `${cmdName} command received`,
+        level: 'info',
+        data: { chatId: ctx.chat?.id, chatType: ctx.chat?.type, userId: ctx.from?.id, username: ctx.from?.username },
+      });
+    }
+    if (isOldMessage && isOldMessage(ctx)) {
+      VERBOSE && console.log(`[VERBOSE] ${cmdName} ignored: old message`);
+      return false;
+    }
+    if (isForwardedOrReply && isForwardedOrReply(ctx)) {
+      VERBOSE && console.log(`[VERBOSE] ${cmdName} ignored: forwarded or reply`);
+      return false;
+    }
+    // Issue #1688: /subscribe and /unsubscribe work in both private and group chats.
+    // In group chats we still require chat/topic authorization so unauthorized
+    // chats cannot use the bot to spam.
+    const chatType = ctx.chat?.type;
+    const isPrivateChat = chatType === 'private';
+    if (!isPrivateChat && isTopicAuthorized && !isTopicAuthorized(ctx)) {
+      VERBOSE && console.log(`[VERBOSE] ${cmdName} ignored: not authorized`);
+      if (buildAuthErrorMessage) {
+        await ctx.reply(buildAuthErrorMessage(ctx), { reply_to_message_id: ctx.message?.message_id });
+      }
+      return false;
+    }
+    if (!ctx.from?.id) {
+      VERBOSE && console.log(`[VERBOSE] ${cmdName} ignored: no user id on update`);
+      return false;
+    }
+    return true;
+  }
+
+  bot.command('subscribe', async ctx => {
+    if (!(await shouldHandle(ctx, '/subscribe'))) return;
+
+    const userId = ctx.from.id;
+    const wasNew = addSubscriber(userId, {
+      username: ctx.from.username,
+      firstName: ctx.from.first_name,
+      sourceChatId: ctx.chat?.id ?? null,
+    });
+
+    let message = SUBSCRIBE_CONFIRMATION;
+    if (!wasNew) {
+      message = 'ℹ️ You are already subscribed.\n\nUse /unsubscribe to stop receiving private notifications when /solve commands finish.';
+    }
+
+    await ctx.reply(message, {
+      parse_mode: 'Markdown',
+      reply_to_message_id: ctx.message?.message_id,
+    });
+
+    VERBOSE && console.log(`[VERBOSE] Subscriber ${userId} (${ctx.from.username || ctx.from.first_name || 'unknown'}) added (new=${wasNew}); total=${getSubscriberCount()}`);
+  });
+
+  bot.command('unsubscribe', async ctx => {
+    if (!(await shouldHandle(ctx, '/unsubscribe'))) return;
+
+    const userId = ctx.from.id;
+    const wasRemoved = removeSubscriber(userId);
+
+    await ctx.reply(wasRemoved ? UNSUBSCRIBE_CONFIRMATION : NOT_SUBSCRIBED_MESSAGE, {
+      parse_mode: 'Markdown',
+      reply_to_message_id: ctx.message?.message_id,
+    });
+
+    VERBOSE && console.log(`[VERBOSE] Subscriber ${userId} (${ctx.from.username || ctx.from.first_name || 'unknown'}) removed=${wasRemoved}; total=${getSubscriberCount()}`);
+  });
+}

package/src/work-session-formatting.lib.mjs

@@ -52,7 +52,38 @@ export function formatExecutingWorkSessionMessage({ sessionName = 'unknown', iso
   return `⏳ Executing...\n\n📊 Session: \`${sessionName}\`${isolationInfo}${details}`;
 }
 
-export function formatSessionCompletionMessage({ sessionName, sessionInfo, statusResult = null, observedEndTime = new Date(), exitCode = null, infoBlock = '' } = {}) {
+/**
+ * Append an extra "Pull request:" line to an existing infoBlock when an issue's
+ * /solve session has produced a PR. Idempotent — already present URLs are not
+ * duplicated.
+ *
+ * @param {string} infoBlock - Existing infoBlock (already contains an Issue: line)
+ * @param {string|null} pullRequestUrl - PR URL discovered after the session completed
+ * @returns {string} New infoBlock
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/1688
+ */
+export function appendPullRequestLine(infoBlock, pullRequestUrl) {
+  if (!pullRequestUrl || !infoBlock) return infoBlock || '';
+  if (infoBlock.includes(pullRequestUrl)) return infoBlock;
+
+  const lines = infoBlock.split('\n');
+  let lastUrlLineIdx = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (/^(Issue|Pull request|URL):\s/.test(lines[i])) {
+      lastUrlLineIdx = i;
+    }
+  }
+  const prLine = `Pull request: ${pullRequestUrl}`;
+  if (lastUrlLineIdx === -1) {
+    return `${infoBlock}\n${prLine}`;
+  }
+  const before = lines.slice(0, lastUrlLineIdx + 1);
+  const after = lines.slice(lastUrlLineIdx + 1);
+  return [...before, prLine, ...after].join('\n');
+}
+
+export function formatSessionCompletionMessage({ sessionName, sessionInfo, statusResult = null, observedEndTime = new Date(), exitCode = null, infoBlock = '', pullRequestUrl = null } = {}) {
   const finalExitCode = getSessionCompletionExitCode({ exitCode, statusResult });
   const failed = finalExitCode !== null && finalExitCode !== 0;
   const statusEmoji = failed ? '❌' : '✅';
@@ -61,7 +92,10 @@ export function formatSessionCompletionMessage({ sessionName, sessionInfo, statu
   const startTime = parseDateValue(statusResult?.startTime) || parseDateValue(sessionInfo?.startTime) || observedEndTime;
   const endTime = parseDateValue(statusResult?.endTime) || observedEndTime;
   const durationSeconds = Math.max(0, (endTime.getTime() - startTime.getTime()) / 1000);
-  const resolvedInfoBlock = infoBlock || sessionInfo?.infoBlock || '';
+  let resolvedInfoBlock = infoBlock || sessionInfo?.infoBlock || '';
+  // Issue #1688: When the agent created a PR for an issue-driven /solve, append
+  //   a 'Pull request:' line so the completion message includes both Issue and PR links.
+  if (pullRequestUrl) resolvedInfoBlock = appendPullRequestLine(resolvedInfoBlock, pullRequestUrl);
   const details = resolvedInfoBlock ? `\n\n${resolvedInfoBlock}` : '';
 
   let message = `${statusEmoji} *${statusText}*\n\n`;