@link-assistant/hive-mind 1.42.0 → 1.44.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @link-assistant/hive-mind
 
+## 1.44.0
+
+### Minor Changes
+
+- e7ce2dd: Add TELEGRAM_ALLOWED_TOPICS for forum topic filtering (issue #1100)
+
+## 1.43.0
+
+### Minor Changes
+
+- 91479e3: Better /version command output with uniform formatting and bug fixes: add regex version parsers for all 40+ tools, fix LLD/Xvfb/Playwright MCP detection, add Playwright browser cache fallback, fail Docker build on MCP registration failure
+
 ## 1.42.0
 
 ### Minor Changes

package/package.json

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

package/src/lino.lib.mjs

@@ -96,6 +96,48 @@ export class LinksNotationManager {
     return [];
   }
 
+  parseLinks(input) {
+    if (!input) return [];
+
+    const parsed = this.parser.parse(input);
+    if (!parsed || parsed.length === 0) return [];
+
+    const link = parsed[0];
+    const pairs = [];
+
+    if (link.values && link.values.length > 0) {
+      const flatNumbers = [];
+
+      for (const value of link.values) {
+        if (value.id === null && value.values && value.values.length >= 2) {
+          const source = parseInt(value.values[0]?.id || value.values[0], 10);
+          const target = parseInt(value.values[1]?.id || value.values[1], 10);
+          if (!isNaN(source) && !isNaN(target)) {
+            pairs.push({ source, target });
+          }
+        } else if (value.id) {
+          const num = parseInt(value.id, 10);
+          if (!isNaN(num)) {
+            flatNumbers.push(num);
+          }
+        }
+      }
+
+      for (let i = 0; i < flatNumbers.length - 1; i += 2) {
+        pairs.push({ source: flatNumbers[i], target: flatNumbers[i + 1] });
+      }
+    }
+
+    return pairs;
+  }
+
+  formatLinks(pairs) {
+    if (!pairs || pairs.length === 0) return '()';
+
+    const formattedValues = pairs.map(pair => `  ${pair.source} ${pair.target}`).join('\n');
+    return `(\n${formattedValues}\n)`;
+  }
+
   format(values) {
     if (!values || values.length === 0) return '()';
 

package/src/telegram-accept-invitations.lib.mjs

@@ -116,10 +116,12 @@ function buildProgressMessage(state) {
  * @param {Function} options.isForwardedOrReply - Function to check if message is forwarded/reply
  * @param {Function} options.isGroupChat - Function to check if chat is a group
  * @param {Function} options.isChatAuthorized - Function to check if chat is authorized
+ * @param {Function} [options.isTopicAuthorized] - Function to check if topic is authorized (issue #1100)
+ * @param {Function} [options.buildAuthErrorMessage] - Function to build authorization error message
  * @param {Function} options.addBreadcrumb - Function to add breadcrumbs for monitoring
  */
 export function registerAcceptInvitesCommand(bot, options) {
-  const { VERBOSE = false, isOldMessage, isForwardedOrReply, isGroupChat, isChatAuthorized, addBreadcrumb } = options;
+  const { VERBOSE = false, isOldMessage, isForwardedOrReply, isGroupChat, isChatAuthorized, isTopicAuthorized, buildAuthErrorMessage, addBreadcrumb } = options;
 
   bot.command(/^accept[_-]?invites$/i, async ctx => {
     VERBOSE && console.log('[VERBOSE] /accept_invites command received');
@@ -134,11 +136,11 @@ export function registerAcceptInvitesCommand(bot, options) {
       return await ctx.reply('❌ The /accept_invites command only works in group chats. Please add this bot to a group and make it an admin.', {
         reply_to_message_id: ctx.message.message_id,
       });
-    const chatId = ctx.chat.id;
-    if (!isChatAuthorized(chatId))
-      return await ctx.reply(`❌ This chat (ID: ${chatId}) is not authorized to use this bot. Please contact the bot administrator.`, {
-        reply_to_message_id: ctx.message.message_id,
-      });
+    const authorize = isTopicAuthorized || (ctx => isChatAuthorized(ctx.chat.id));
+    if (!authorize(ctx)) {
+      const errMsg = buildAuthErrorMessage ? buildAuthErrorMessage(ctx) : `❌ This chat (ID: ${ctx.chat.id}) is not authorized.`;
+      return await ctx.reply(errMsg, { reply_to_message_id: ctx.message.message_id });
+    }
 
     const fetchingMessage = await ctx.reply('🔄 Fetching pending GitHub invitations\\.\\.\\.', {
       reply_to_message_id: ctx.message.message_id,

package/src/telegram-bot.mjs

@@ -78,6 +78,12 @@ const config = yargs(hideBin(process.argv))
     alias: 'allowed-chats',
     default: getenv('TELEGRAM_ALLOWED_CHATS', ''),
   })
+  .option('allowedTopics', {
+    type: 'string',
+    description: 'Allowed topic IDs in Links Notation format "chatId topicId" pairs',
+    alias: 'allowed-topics',
+    default: getenv('TELEGRAM_ALLOWED_TOPICS', ''),
+  })
   .option('solveOverrides', {
     type: 'string',
     description: 'Override options for /solve command in lino notation, e.g., "(\n  --auto-continue\n  --attach-logs\n)"',
@@ -154,6 +160,10 @@ if (!BOT_TOKEN) {
 const resolvedAllowedChats = config.allowedChats || getenv('TELEGRAM_ALLOWED_CHATS', '');
 const allowedChats = resolvedAllowedChats ? lino.parseNumericIds(resolvedAllowedChats) : null;
 
+// Parse allowed topics (chatId:topicId pairs in Links Notation)
+const resolvedAllowedTopics = config.allowedTopics || getenv('TELEGRAM_ALLOWED_TOPICS', '');
+const allowedTopics = resolvedAllowedTopics ? lino.parseLinks(resolvedAllowedTopics) : null;
+
 // Parse override options
 const resolvedSolveOverrides = config.solveOverrides || getenv('TELEGRAM_SOLVE_OVERRIDES', '');
 const solveOverrides = resolvedSolveOverrides
@@ -277,6 +287,9 @@ if (config.dryRun) {
   } else {
     console.log('  Allowed chats: All (no restrictions)');
   }
+  if (allowedTopics && allowedTopics.length > 0) {
+    console.log('  Allowed topics:', lino.formatLinks(allowedTopics));
+  }
   console.log('  Commands enabled:', { solve: solveEnabled, hive: hiveEnabled });
   if (solveOverrides.length > 0) {
     console.log('  Solve overrides:', lino.format(solveOverrides));
@@ -319,6 +332,22 @@ function isChatAuthorized(chatId) {
   return _isChatAuthorized(chatId, allowedChats);
 }
 
+// Topic-level authorization (issue #1100): chat-level auth overrides topic-level
+function isTopicAuthorized(ctx) {
+  if (isChatAuthorized(ctx.chat?.id)) return true;
+  if (!allowedTopics || allowedTopics.length === 0) return false;
+  const chatId = ctx.chat?.id;
+  const topicId = ctx.message?.message_thread_id;
+  return allowedTopics.some(pair => pair.source === chatId && pair.target === topicId);
+}
+function buildAuthErrorMessage(ctx) {
+  const chatId = ctx.chat?.id;
+  const topicId = ctx.message?.message_thread_id;
+  let msg = `❌ This chat (ID: ${chatId})`;
+  if (topicId) msg += ` and topic (ID: ${topicId})`;
+  return msg + ' is not authorized.\n\nUse /help to see your chat and topic IDs.';
+}
+
 function isOldMessage(ctx) {
   return _isOldMessage(ctx, BOT_START_TIME, { verbose: VERBOSE });
 }
@@ -621,7 +650,7 @@ bot.command('help', async ctx => {
   const chatId = ctx.chat.id;
   const chatType = ctx.chat.type;
   const chatTitle = ctx.chat.title || 'Private Chat';
-
+  const topicId = ctx.message?.message_thread_id; // Forum topic ID (issue #1100)
   let message = '🤖 *SwarmMindBot Help*\n\n';
 
   // Show stopped status if chat is stopped (issue #1081)
@@ -638,6 +667,7 @@ bot.command('help', async ctx => {
 
   message += '📋 *Diagnostic Information:*\n';
   message += `• Chat ID: \`${chatId}\`\n`;
+  if (topicId) message += `• Topic ID: \`${topicId}\`\n`;
   message += `• Chat Type: ${chatType}\n`;
   message += `• Chat Title: ${chatTitle}\n\n`;
   message += '📝 *Available Commands:*\n\n';
@@ -685,9 +715,10 @@ bot.command('help', async ctx => {
   message += '• `--verbose` or `-v` - Verbose output | `--attach-logs` - Attach logs to PR\n';
   message += '\n💡 *Tip:* Many more options available. See full documentation for complete list.\n';
 
-  if (allowedChats) {
-    message += '\n🔒 *Restricted Mode:* This bot only accepts commands from authorized chats.\n';
-    message += `Authorized: ${isChatAuthorized(chatId) ? '✅ Yes' : '❌ No'}`;
+  if (allowedChats || allowedTopics) {
+    const authorized = isTopicAuthorized(ctx);
+    message += `\n🔒 *Restricted Mode:* Authorized: ${authorized ? '✅ Yes' : '❌ No'}`;
+    if (!authorized && topicId) message += `\n💡 To allow this topic: \`TELEGRAM_ALLOWED_TOPICS="(${chatId} ${topicId})"\``;
   }
 
   message += '\n\n🔧 *Troubleshooting:*\n';
@@ -728,10 +759,11 @@ bot.command('limits', async ctx => {
     return;
   }
 
-  const chatId = ctx.chat.id;
-  if (!isChatAuthorized(chatId)) {
-    VERBOSE && console.log('[VERBOSE] /limits ignored: chat not authorized');
-    await ctx.reply(`❌ This chat (ID: ${chatId}) is not authorized to use this bot. Please contact the bot administrator.`, { reply_to_message_id: ctx.message.message_id });
+  if (!isTopicAuthorized(ctx)) {
+    if (VERBOSE) {
+      console.log('[VERBOSE] /limits ignored: not authorized');
+    }
+    await ctx.reply(buildAuthErrorMessage(ctx), { reply_to_message_id: ctx.message.message_id });
     return;
   }
 
@@ -768,8 +800,7 @@ bot.command('version', async ctx => {
   });
   if (isOldMessage(ctx) || isForwardedOrReply(ctx)) return;
   if (!_isGroupChat(ctx)) return await ctx.reply('❌ The /version command only works in group chats. Please add this bot to a group and make it an admin.', { reply_to_message_id: ctx.message.message_id });
-  const chatId = ctx.chat.id;
-  if (!isChatAuthorized(chatId)) return await ctx.reply(`❌ This chat (ID: ${chatId}) is not authorized to use this bot. Please contact the bot administrator.`, { reply_to_message_id: ctx.message.message_id });
+  if (!isTopicAuthorized(ctx)) return await ctx.reply(buildAuthErrorMessage(ctx), { reply_to_message_id: ctx.message.message_id });
   const fetchingMessage = await ctx.reply('🔄 Gathering version information...', {
     reply_to_message_id: ctx.message.message_id,
   });
@@ -778,48 +809,18 @@ 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 /accept_invites command from separate module
-// This keeps telegram-bot.mjs under the 1500 line limit
+// Register external command modules (keeps telegram-bot.mjs under line limit)
 const { registerAcceptInvitesCommand } = await import('./telegram-accept-invitations.lib.mjs');
-registerAcceptInvitesCommand(bot, {
-  VERBOSE,
-  isOldMessage,
-  isForwardedOrReply,
-  isGroupChat: _isGroupChat,
-  isChatAuthorized,
-  addBreadcrumb,
-});
-
-// Register /merge command from separate module (experimental, see issue #1143)
+const sharedCommandOpts = { VERBOSE, isOldMessage, isForwardedOrReply, isGroupChat: _isGroupChat, isChatAuthorized, isTopicAuthorized, buildAuthErrorMessage, addBreadcrumb, isChatStopped, getStoppedChatRejectMessage };
+registerAcceptInvitesCommand(bot, sharedCommandOpts);
 const { registerMergeCommand } = await import('./telegram-merge-command.lib.mjs');
-registerMergeCommand(bot, {
-  VERBOSE,
-  isOldMessage,
-  isForwardedOrReply,
-  isGroupChat: _isGroupChat,
-  isChatAuthorized,
-  addBreadcrumb,
-  isChatStopped,
-  getStoppedChatRejectMessage,
-});
-
-// Register /solve_queue command from separate module (issue #1232)
+registerMergeCommand(bot, sharedCommandOpts);
 const { registerSolveQueueCommand } = await import('./telegram-solve-queue-command.lib.mjs');
-const { handleSolveQueueCommand } = registerSolveQueueCommand(bot, {
-  VERBOSE,
-  isOldMessage,
-  isForwardedOrReply,
-  isGroupChat: _isGroupChat,
-  isChatAuthorized,
-  addBreadcrumb,
-  getSolveQueue,
-});
+const { handleSolveQueueCommand } = registerSolveQueueCommand(bot, { ...sharedCommandOpts, getSolveQueue });
 
 // Named handler for /solve command - extracted for reuse by text-based fallback (issue #1207)
 async function handleSolveCommand(ctx) {
-  if (VERBOSE) {
-    console.log('[VERBOSE] /solve command received');
-  }
+  VERBOSE && console.log('[VERBOSE] /solve command received');
 
   // Add breadcrumb for error tracking
   await addBreadcrumb({
@@ -871,16 +872,16 @@ async function handleSolveCommand(ctx) {
     return;
   }
 
-  const chatId = ctx.chat.id;
-  if (!isChatAuthorized(chatId)) {
+  if (!isTopicAuthorized(ctx)) {
     if (VERBOSE) {
-      console.log('[VERBOSE] /solve ignored: chat not authorized');
+      console.log('[VERBOSE] /solve ignored: not authorized');
     }
-    await ctx.reply(`❌ This chat (ID: ${chatId}) is not authorized to use this bot. Please contact the bot administrator.`, { reply_to_message_id: ctx.message.message_id });
+    await ctx.reply(buildAuthErrorMessage(ctx), { reply_to_message_id: ctx.message.message_id });
     return;
   }
 
   // Check if chat is stopped (issue #1081) - reject with same style as queue rejected mode
+  const chatId = ctx.chat.id;
   if (isChatStopped(chatId)) {
     VERBOSE && console.log('[VERBOSE] /solve rejected: chat is stopped');
     await safeReply(ctx, getStoppedChatRejectMessage(chatId, 'Solve'), { reply_to_message_id: ctx.message.message_id });
@@ -1017,7 +1018,7 @@ async function handleSolveCommand(ctx) {
   const existingItem = solveQueue.findByUrl(normalizedUrl);
   if (existingItem) {
     const statusText = existingItem.status === 'starting' || existingItem.status === 'started' ? 'being processed' : 'already in the queue';
-    await safeReply(ctx, `❌ This URL is ${statusText}.\n\nURL: ${escapeMarkdown(normalizedUrl)}\nStatus: ${existingItem.status}\n\n💡 Use /solve\\_queue to check the queue status.`, { reply_to_message_id: ctx.message.message_id });
+    await safeReply(ctx, `❌ This URL is ${statusText}.\n\nURL: ${escapeMarkdown(normalizedUrl)}\nStatus: ${existingItem.status}\n\n💡 Use /solve_queue to check the queue status.`, { reply_to_message_id: ctx.message.message_id });
     return;
   }
 
@@ -1099,16 +1100,16 @@ async function handleHiveCommand(ctx) {
     return;
   }
 
-  const chatId = ctx.chat.id;
-  if (!isChatAuthorized(chatId)) {
+  if (!isTopicAuthorized(ctx)) {
     if (VERBOSE) {
-      console.log('[VERBOSE] /hive ignored: chat not authorized');
+      console.log('[VERBOSE] /hive ignored: not authorized');
     }
-    await ctx.reply(`❌ This chat (ID: ${chatId}) is not authorized to use this bot. Please contact the bot administrator.`, { reply_to_message_id: ctx.message.message_id });
+    await ctx.reply(buildAuthErrorMessage(ctx), { reply_to_message_id: ctx.message.message_id });
     return;
   }
 
   // Check if chat is stopped (issue #1081) - reject with same style as queue rejected mode
+  const chatId = ctx.chat.id;
   if (isChatStopped(chatId)) {
     VERBOSE && console.log('[VERBOSE] /hive rejected: chat is stopped');
     await safeReply(ctx, getStoppedChatRejectMessage(chatId, 'Hive'), { reply_to_message_id: ctx.message.message_id });
@@ -1201,12 +1202,10 @@ async function handleHiveCommand(ctx) {
 
 bot.command(/^hive$/i, handleHiveCommand);
 
-// Register commands from separate modules (keeps telegram-bot.mjs under line limit)
 const { registerTopCommand } = await import('./telegram-top-command.lib.mjs');
 const { registerStartStopCommands } = await import('./telegram-start-stop-command.lib.mjs');
-const commandOptions = { VERBOSE, isOldMessage, isForwardedOrReply, isGroupChat: _isGroupChat, isChatAuthorized };
-registerTopCommand(bot, commandOptions);
-registerStartStopCommands(bot, commandOptions); // issue #1081
+registerTopCommand(bot, sharedCommandOpts);
+registerStartStopCommands(bot, sharedCommandOpts);
 
 // Add message listener for verbose debugging
 if (VERBOSE) {
@@ -1389,6 +1388,9 @@ if (allowedChats && allowedChats.length > 0) {
 } else {
   console.log('Allowed chats: All (no restrictions)');
 }
+if (allowedTopics && allowedTopics.length > 0) {
+  console.log('Allowed topics (lino):', lino.formatLinks(allowedTopics));
+}
 console.log('Commands enabled:', { solve: solveEnabled, hive: hiveEnabled });
 if (solveOverrides.length > 0) console.log('Solve overrides (lino):', lino.format(solveOverrides));
 if (hiveOverrides.length > 0) console.log('Hive overrides (lino):', lino.format(hiveOverrides));

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

@@ -130,10 +130,14 @@ function formatUserError(error, verbose) {
  * @param {Function} options.isForwardedOrReply - Function to check if message is forwarded/reply
  * @param {Function} options.isGroupChat - Function to check if chat is a group
  * @param {Function} options.isChatAuthorized - Function to check if chat is authorized
+ * @param {Function} [options.isTopicAuthorized] - Function to check if topic is authorized (issue #1100)
+ * @param {Function} [options.buildAuthErrorMessage] - Function to build authorization error message
  * @param {Function} options.addBreadcrumb - Function to add breadcrumbs for monitoring
+ * @param {Function} [options.isChatStopped] - Function to check if chat is stopped (issue #1081)
+ * @param {Function} [options.getStoppedChatRejectMessage] - Function to get stopped chat rejection message
  */
 export function registerMergeCommand(bot, options) {
-  const { VERBOSE = false, isOldMessage, isForwardedOrReply, isGroupChat, isChatAuthorized, addBreadcrumb, isChatStopped, getStoppedChatRejectMessage } = options;
+  const { VERBOSE = false, isOldMessage, isForwardedOrReply, isGroupChat, isChatAuthorized, isTopicAuthorized, buildAuthErrorMessage, addBreadcrumb, isChatStopped, getStoppedChatRejectMessage } = options;
 
   bot.command(/^merge$/i, async ctx => {
     VERBOSE && console.log('[VERBOSE] /merge command received');
@@ -154,13 +158,14 @@ export function registerMergeCommand(bot, options) {
       });
     }
 
-    const chatId = ctx.chat.id;
-    if (!isChatAuthorized(chatId)) {
-      return await ctx.reply(`This chat (ID: ${chatId}) is not authorized to use this bot. Please contact the bot administrator.`, {
-        reply_to_message_id: ctx.message.message_id,
-      });
+    const authorize = isTopicAuthorized || (ctx => isChatAuthorized(ctx.chat.id));
+    if (!authorize(ctx)) {
+      const errMsg = buildAuthErrorMessage ? buildAuthErrorMessage(ctx) : `This chat (ID: ${ctx.chat.id}) is not authorized.`;
+      return await ctx.reply(errMsg, { reply_to_message_id: ctx.message.message_id });
     }
 
+    const chatId = ctx.chat.id;
+
     // Check if chat is stopped (issue #1081) - reject with same style as queue rejected mode
     if (isChatStopped && isChatStopped(chatId)) {
       VERBOSE && console.log('[VERBOSE] /merge rejected: chat is stopped');

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

@@ -22,12 +22,14 @@
  * @param {Function} options.isForwardedOrReply - Function to check if message is forwarded/reply
  * @param {Function} options.isGroupChat - Function to check if chat is a group
  * @param {Function} options.isChatAuthorized - Function to check if chat is authorized
+ * @param {Function} [options.isTopicAuthorized] - Function to check if topic is authorized (issue #1100)
+ * @param {Function} [options.buildAuthErrorMessage] - Function to build authorization error message
  * @param {Function} options.addBreadcrumb - Function to add breadcrumbs for monitoring
  * @param {Function} options.getSolveQueue - Function to get the solve queue instance
  * @returns {{ handleSolveQueueCommand: Function }} The command handler for use in text fallback
  */
 export function registerSolveQueueCommand(bot, options) {
-  const { VERBOSE = false, isOldMessage, isForwardedOrReply, isGroupChat, isChatAuthorized, addBreadcrumb, getSolveQueue } = options;
+  const { VERBOSE = false, isOldMessage, isForwardedOrReply, isGroupChat, isChatAuthorized, isTopicAuthorized, buildAuthErrorMessage, addBreadcrumb, getSolveQueue } = options;
 
   async function handleSolveQueueCommand(ctx) {
     VERBOSE && console.log('[VERBOSE] /solve_queue command received');
@@ -59,12 +61,11 @@ export function registerSolveQueueCommand(bot, options) {
       return;
     }
 
-    const chatId = ctx.chat.id;
-    if (!isChatAuthorized(chatId)) {
-      VERBOSE && console.log('[VERBOSE] /solve_queue ignored: chat not authorized');
-      await ctx.reply(`❌ This chat (ID: ${chatId}) is not authorized to use this bot. Please contact the bot administrator.`, {
-        reply_to_message_id: ctx.message.message_id,
-      });
+    const authorize = isTopicAuthorized || (ctx => isChatAuthorized(ctx.chat.id));
+    if (!authorize(ctx)) {
+      VERBOSE && console.log('[VERBOSE] /solve_queue ignored: not authorized');
+      const errMsg = buildAuthErrorMessage ? buildAuthErrorMessage(ctx) : `❌ This chat (ID: ${ctx.chat.id}) is not authorized.`;
+      await ctx.reply(errMsg, { reply_to_message_id: ctx.message.message_id });
       return;
     }
 

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

@@ -51,9 +51,11 @@ async function captureTopOutput(chatId) {
  * @param {Function} options.isForwardedOrReply - Function to check if message is forwarded/reply
  * @param {Function} options.isGroupChat - Function to check if chat is a group
  * @param {Function} options.isChatAuthorized - Function to check if chat is authorized
+ * @param {Function} [options.isTopicAuthorized] - Function to check if topic is authorized (issue #1100)
+ * @param {Function} [options.buildAuthErrorMessage] - Function to build authorization error message
  */
 export function registerTopCommand(bot, options) {
-  const { VERBOSE = false, isOldMessage, isForwardedOrReply, isGroupChat, isChatAuthorized } = options;
+  const { VERBOSE = false, isOldMessage, isForwardedOrReply, isGroupChat, isChatAuthorized, isTopicAuthorized, buildAuthErrorMessage } = options;
 
   // /top command - show system top output in an auto-updating message (EXPERIMENTAL)
   // Only accessible by chat owner
@@ -89,17 +91,20 @@ export function registerTopCommand(bot, options) {
       return;
     }
 
-    const chatId = ctx.chat.id;
-    if (!isChatAuthorized(chatId)) {
+    const authorize = isTopicAuthorized || (ctx => isChatAuthorized(ctx.chat.id));
+    if (!authorize(ctx)) {
       if (VERBOSE) {
-        console.log('[VERBOSE] /top ignored: chat not authorized');
+        console.log('[VERBOSE] /top ignored: not authorized');
       }
-      await ctx.reply(`❌ This chat (ID: ${chatId}) is not authorized to use this bot.`, {
+      const errMsg = buildAuthErrorMessage ? buildAuthErrorMessage(ctx) : `❌ This chat (ID: ${ctx.chat.id}) is not authorized.`;
+      await ctx.reply(errMsg, {
         reply_to_message_id: ctx.message.message_id,
       });
       return;
     }
 
+    const chatId = ctx.chat.id;
+
     // Check if user is chat owner
     try {
       const chatMember = await ctx.telegram.getChatMember(chatId, ctx.from.id);

package/src/version-info.lib.mjs

@@ -33,6 +33,397 @@ async function execCommandAsync(command, timeout = 5000) {
   }
 }
 
+/**
+ * Per-tool regex parsers to normalize raw --version output into uniform format:
+ *   <version> (<commit>, <revision>, <date>, etc.)
+ *
+ * Each parser returns { version, extra[] } or null if it doesn't match.
+ * The `version` is the most specific version string (for bug reporting).
+ * Items in `extra` are joined with ", " and placed in parentheses.
+ *
+ * @type {Record<string, (raw: string) => {version: string, extra: string[]} | null>}
+ */
+const VERSION_PARSERS = {
+  // rustc 1.94.1 (e408947bf 2026-03-25)
+  rust: raw => {
+    const m = raw.match(/^rustc\s+([\d.]+(?:-\S+)?)\s*(?:\(([^)]+)\))?/);
+    if (!m) return null;
+    const extra = m[2] ? m[2].trim().split(/\s+/) : [];
+    return { version: m[1], extra };
+  },
+  // cargo 1.94.1 (29ea6fb6a 2026-03-24)
+  cargo: raw => {
+    const m = raw.match(/^cargo\s+([\d.]+(?:-\S+)?)\s*(?:\(([^)]+)\))?/);
+    if (!m) return null;
+    const extra = m[2] ? m[2].trim().split(/\s+/) : [];
+    return { version: m[1], extra };
+  },
+  // go version go1.26.1 linux/amd64
+  go: raw => {
+    const m = raw.match(/go([\d.]+(?:\S*)?)\s+(.*)/);
+    if (!m) return null;
+    return { version: m[1], extra: [m[2].trim()] };
+  },
+  // PHP 8.3.30 (cli) (built: Jan 13 2026 22:36:55) (NTS)
+  php: raw => {
+    const m = raw.match(/^PHP\s+([\d.]+(?:-\S+)?)\s*(.*)/);
+    if (!m) return null;
+    const tags = [];
+    const parts = m[2].matchAll(/\(([^)]+)\)/g);
+    for (const p of parts) tags.push(p[1]);
+    return { version: m[1], extra: tags };
+  },
+  // openjdk version "21" 2023-09-19 LTS
+  java: raw => {
+    const m = raw.match(/version\s+"([^"]+)"(?:\s+(.+))?/);
+    if (!m) return null;
+    return { version: m[1], extra: m[2] ? [m[2].trim()] : [] };
+  },
+  // gcc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0 — use full distro version
+  gcc: raw => {
+    const m = raw.match(/^gcc\s+(?:\((\S+)\s+([\d.]+\S*)\)\s+)?([\d.]+)/);
+    if (!m) return null;
+    // If distro info present, use full distro version (e.g. 13.3.0-6ubuntu2~24.04.1)
+    if (m[1] && m[2]) return { version: m[2], extra: [] };
+    return { version: m[3], extra: [] };
+  },
+  // g++ (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0 — use full distro version
+  gpp: raw => {
+    const m = raw.match(/^g\+\+\s+(?:\((\S+)\s+([\d.]+\S*)\)\s+)?([\d.]+)/);
+    if (!m) return null;
+    // If distro info present, use full distro version (e.g. 13.3.0-6ubuntu2~24.04.1)
+    if (m[1] && m[2]) return { version: m[2], extra: [] };
+    return { version: m[3], extra: [] };
+  },
+  // clang version 17.0.0 (https://github.com/... commit)
+  clang: raw => {
+    const m = raw.match(/^clang\s+version\s+([\d.]+(?:-\S+)?)\s*(?:\(([^)]+)\))?/);
+    if (!m) return null;
+    return { version: m[1], extra: m[2] ? [m[2].trim()] : [] };
+  },
+  // LLD 17.0.0 (compatible with GNU linkers) — only version number matters
+  lld: raw => {
+    const m = raw.match(/^LLD\s+([\d.]+)/);
+    if (!m) return null;
+    return { version: m[1], extra: [] };
+  },
+  // Python 3.14.3
+  python: raw => {
+    const m = raw.match(/^Python\s+([\d.]+(?:\S*)?)/);
+    if (!m) return null;
+    return { version: m[1], extra: [] };
+  },
+  // ruby 3.4.9 (2026-03-11 revision 76cca827ab) +PRISM [x86_64-linux]
+  ruby: raw => {
+    const m = raw.match(/^ruby\s+([\d.]+(?:p\d+)?)\s*(?:\(([^)]+)\))?\s*(.*)/);
+    if (!m) return null;
+    const extra = [];
+    if (m[2]) extra.push(m[2].trim());
+    const tail = m[3] ? m[3].trim() : '';
+    if (tail) extra.push(tail);
+    return { version: m[1], extra };
+  },
+  // Kotlin version 2.3.20-release-208 (JRE 21+35-LTS)
+  kotlin: raw => {
+    const m = raw.match(/^Kotlin\s+version\s+([\d.\-\w]+)\s*(?:\(([^)]+)\))?/);
+    if (!m) return null;
+    return { version: m[1], extra: m[2] ? [m[2].trim()] : [] };
+  },
+  // Swift version 6.0.3 (swift-6.0.3-RELEASE)
+  swift: raw => {
+    const m = raw.match(/^Swift\s+version\s+([\d.]+(?:\.\d+)?)\s*(?:\(([^)]+)\))?/);
+    if (!m) return null;
+    return { version: m[1], extra: m[2] ? [m[2].trim()] : [] };
+  },
+  // R version 4.3.3 (2024-02-29) -- "Angel Food Cake"
+  r: raw => {
+    const m = raw.match(/^R\s+version\s+([\d.]+)\s*(?:\(([^)]+)\))?(?:\s+--\s+"([^"]+)")?/);
+    if (!m) return null;
+    const extra = [];
+    if (m[2]) extra.push(m[2]);
+    if (m[3]) extra.push(m[3]);
+    return { version: m[1], extra };
+  },
+  // git version 2.43.0
+  git: raw => {
+    const m = raw.match(/^git\s+version\s+([\d.]+)/);
+    if (!m) return null;
+    return { version: m[1], extra: [] };
+  },
+  // gh version 2.89.0 (2026-03-26)
+  gh: raw => {
+    const m = raw.match(/^gh\s+version\s+([\d.]+)\s*(?:\(([^)]+)\))?/);
+    if (!m) return null;
+    return { version: m[1], extra: m[2] ? [m[2]] : [] };
+  },
+  // glab version 1.36.0
+  glab: raw => {
+    const m = raw.match(/^glab\s+version\s+([\d.]+)/);
+    if (!m) return null;
+    return { version: m[1], extra: [] };
+  },
+  // curl 8.19.0 (x86_64-pc-linux-gnu) libcurl/8.19.0 ...
+  curl: raw => {
+    const m = raw.match(/^curl\s+([\d.]+)\s*(?:\(([^)]+)\))?/);
+    if (!m) return null;
+    return { version: m[1], extra: m[2] ? [m[2]] : [] };
+  },
+  // GNU Wget 1.21.4 built on linux-gnu.
+  wget: raw => {
+    const m = raw.match(/^GNU\s+Wget\s+([\d.]+)/);
+    if (!m) return null;
+    return { version: m[1], extra: [] };
+  },
+  // cmake version 3.28.3
+  cmake: raw => {
+    const m = raw.match(/^cmake\s+version\s+([\d.]+)/);
+    if (!m) return null;
+    return { version: m[1], extra: [] };
+  },
+  // GNU Make 4.3
+  make: raw => {
+    const m = raw.match(/^GNU\s+Make\s+([\d.]+)/);
+    if (!m) return null;
+    return { version: m[1], extra: [] };
+  },
+  // NASM version 2.16.01
+  nasm: raw => {
+    const m = raw.match(/^NASM\s+version\s+([\d.]+)/);
+    if (!m) return null;
+    return { version: m[1], extra: [] };
+  },
+  // flat assembler  version 1.73.32
+  fasm: raw => {
+    const m = raw.match(/version\s+([\d.]+)/);
+    if (!m) return null;
+    return { version: m[1], extra: [] };
+  },
+  // Screen version 4.09.01 (GNU) 20-Aug-23
+  screen: raw => {
+    const m = raw.match(/^Screen\s+version\s+([\d.]+)\s*(?:\(([^)]+)\))?\s*(.*)/);
+    if (!m) return null;
+    const extra = [];
+    if (m[2]) extra.push(m[2]);
+    if (m[3] && m[3].trim()) extra.push(m[3].trim());
+    return { version: m[1], extra };
+  },
+  // expect version 5.45.4
+  expect: raw => {
+    const m = raw.match(/^expect\s+version\s+([\d.]+)/);
+    if (!m) return null;
+    return { version: m[1], extra: [] };
+  },
+  // The OCaml toplevel, version 5.4.1
+  ocaml: raw => {
+    const m = raw.match(/version\s+([\d.]+)/);
+    if (!m) return null;
+    return { version: m[1], extra: [] };
+  },
+  // The Rocq Prover, version 9.1.1
+  rocq: raw => {
+    const m = raw.match(/version\s+([\d.]+)/);
+    if (!m) return null;
+    return { version: m[1], extra: [] };
+  },
+  // elan 4.2.1 (3d5138e15 2026-03-18)
+  elan: raw => {
+    const m = raw.match(/^elan\s+([\d.]+)\s*(?:\(([^)]+)\))?/);
+    if (!m) return null;
+    const extra = m[2] ? m[2].trim().split(/\s+/) : [];
+    return { version: m[1], extra };
+  },
+  // Lean (version 4.29.0, x86_64-unknown-linux-gnu, commit abc123, Release)
+  lean: raw => {
+    const m = raw.match(/version\s+([\d.]+)(?:,\s*(.+?))\)?$/);
+    if (!m) return null;
+    const extra = m[2]
+      ? m[2]
+          .split(',')
+          .map(s => s.trim().replace(/\)$/, ''))
+          .filter(Boolean)
+      : [];
+    return { version: m[1], extra };
+  },
+  // Google Chrome 146.0.7680.164
+  chrome: raw => {
+    const m = raw.match(/^Google\s+Chrome\s+([\d.]+)/);
+    if (!m) return null;
+    return { version: m[1], extra: [] };
+  },
+  // Chromium 137.0.7151.0
+  chromium: raw => {
+    const m = raw.match(/^Chromium\s+([\d.]+)/);
+    if (!m) return null;
+    return { version: m[1], extra: [] };
+  },
+  // Mozilla Firefox 139.0
+  firefox: raw => {
+    const m = raw.match(/^Mozilla\s+Firefox\s+([\d.]+)/);
+    if (!m) return null;
+    return { version: m[1], extra: [] };
+  },
+  // Microsoft Edge 146.0.3856.84
+  msedge: raw => {
+    const m = raw.match(/^Microsoft\s+Edge\s+([\d.]+)/);
+    if (!m) return null;
+    return { version: m[1], extra: [] };
+  },
+  // deno 2.7.9 (stable, release, x86_64-unknown-linux-gnu)
+  deno: raw => {
+    const m = raw.match(/^deno\s+([\d.]+)\s*(?:\(([^)]+)\))?/);
+    if (!m) return null;
+    const extra = m[2]
+      ? m[2]
+          .split(',')
+          .map(s => s.trim())
+          .filter(Boolean)
+      : [];
+    return { version: m[1], extra };
+  },
+  // Version 1.58.2  (Playwright CLI)
+  playwright: raw => {
+    const m = raw.match(/(?:Version\s+)?([\d.]+)/);
+    if (!m) return null;
+    return { version: m[1], extra: [] };
+  },
+  // @playwright/test@1.58.2
+  playwrightTest: raw => {
+    const m = raw.match(/@playwright\/test@([\d.]+)/);
+    if (!m) return null;
+    return { version: m[1], extra: [] };
+  },
+  // @playwright/mcp@0.0.69 or `-- @playwright/mcp@0.0.69
+  playwrightMcp: raw => {
+    const m = raw.match(/@playwright\/mcp@([\d.]+)/);
+    if (!m) return null;
+    return { version: m[1], extra: [] };
+  },
+  // @puppeteer/browsers@2.13.0
+  puppeteerBrowsers: raw => {
+    const m = raw.match(/@puppeteer\/browsers@([\d.]+)/);
+    if (!m) return null;
+    return { version: m[1], extra: [] };
+  },
+  // 2.1.87 (Claude Code)
+  claudeCode: raw => {
+    const m = raw.match(/([\d.]+)\s*(?:\(([^)]+)\))?/);
+    if (!m) return null;
+    return { version: m[1], extra: m[2] ? [m[2]] : [] };
+  },
+  // GitHub Copilot CLI 1.0.14.\nRun 'copilot update'...
+  copilot: raw => {
+    const m = raw.match(/([\d.]+)/);
+    if (!m) return null;
+    // Strip trailing dot from version (e.g. "1.0.14." -> "1.0.14")
+    const version = m[1].replace(/\.$/, '');
+    return { version, extra: [] };
+  },
+  // pyenv 2.6.26
+  pyenv: raw => {
+    const m = raw.match(/^pyenv\s+([\d.]+)/);
+    if (!m) return null;
+    return { version: m[1], extra: [] };
+  },
+  // /workspace/.perl5/bin/perlbrew  - App::perlbrew/1.02
+  perlbrew: raw => {
+    const m = raw.match(/App::perlbrew\/([\d.]+)/);
+    if (!m) return null;
+    return { version: m[1], extra: [] };
+  },
+  // rbenv 1.3.2-20-g23c3041
+  rbenv: raw => {
+    const m = raw.match(/^rbenv\s+([\d.]+(?:-[\w]+)*)/);
+    if (!m) return null;
+    return { version: m[1], extra: [] };
+  },
+  // Homebrew 5.1.2
+  brew: raw => {
+    const m = raw.match(/^Homebrew\s+([\d.]+)/);
+    if (!m) return null;
+    return { version: m[1], extra: [] };
+  },
+  // This is Zip 3.0 (July 5th 2008), by Info-ZIP.
+  zip: raw => {
+    const m = raw.match(/Zip\s+([\d.]+)\s*(?:\(([^)]+)\))?/);
+    if (!m) return null;
+    return { version: m[1], extra: m[2] ? [m[2]] : [] };
+  },
+  // UnZip 6.00 of 20 April 2009, by Debian.
+  unzip: raw => {
+    const m = raw.match(/UnZip\s+([\d.]+)\s*(?:of\s+([^,]+))?/);
+    if (!m) return null;
+    return { version: m[1], extra: m[2] ? [m[2].trim()] : [] };
+  },
+  // ii  xvfb  2:21.1.12-1ubuntu1.5  amd64  Virtual Framebuffer...
+  xvfb: raw => {
+    // dpkg output format
+    const dpkg = raw.match(/^ii\s+xvfb\s+(\S+)/);
+    if (dpkg) {
+      // Strip epoch (e.g. "2:21.1.12-1ubuntu1.5" -> "21.1.12-1ubuntu1.5")
+      const ver = dpkg[1].replace(/^\d+:/, '');
+      return { version: ver, extra: [] };
+    }
+    // X.Org X Server version output (if it ever works)
+    const xorg = raw.match(/X\.Org\s+X\s+Server\s+([\d.]+)/);
+    if (xorg) return { version: xorg[1], extra: [] };
+    return null;
+  },
+  // Xvfb returns "Unrecognized option: -version" — this is handled by fixing the command
+  // to use dpkg fallback first
+
+  // agent 1.0.0 or similar
+  agent: raw => {
+    const m = raw.match(/([\d.]+)/);
+    if (!m) return null;
+    return { version: m[1], extra: [] };
+  },
+  // codex-cli 0.117.0 or similar
+  codex: raw => {
+    const m = raw.match(/([\d.]+)/);
+    if (!m) return null;
+    return { version: m[1], extra: [] };
+  },
+  // opencode 1.3.10 or similar
+  opencode: raw => {
+    const m = raw.match(/([\d.]+)/);
+    if (!m) return null;
+    return { version: m[1], extra: [] };
+  },
+  // qwen-code version
+  qwenCode: raw => {
+    const m = raw.match(/([\d.]+)/);
+    if (!m) return null;
+    return { version: m[1], extra: [] };
+  },
+  // gemini version
+  gemini: raw => {
+    const m = raw.match(/([\d.]+)/);
+    if (!m) return null;
+    return { version: m[1], extra: [] };
+  },
+};
+
+/**
+ * Parse a raw version string using the per-tool parser, returning uniform format:
+ *   "<version>" or "<version> (<extra1>, <extra2>, ...)"
+ * Falls back to the raw string if no parser matches.
+ * @param {string} key - Tool key (must match a key in VERSION_PARSERS)
+ * @param {string} raw - Raw version string from command output
+ * @returns {string} Parsed version string in uniform format
+ */
+export function parseVersion(key, raw) {
+  if (!raw) return raw;
+  const parser = VERSION_PARSERS[key];
+  if (!parser) return raw;
+  const result = parser(raw);
+  if (!result) return raw;
+  const { version, extra } = result;
+  if (extra && extra.length > 0) {
+    return `${version} (${extra.join(', ')})`;
+  }
+  return version;
+}
+
 /**
  * Command definitions for version checking
  * Each entry has: key, command, and optional fallbacks
@@ -57,8 +448,8 @@ const VERSION_COMMANDS = [
 
   // Browsers (installed via Playwright)
   { key: 'chrome', command: 'google-chrome --version 2>&1' },
-  { key: 'chromium', command: 'chromium --version 2>&1', fallbacks: ['chromium-browser --version 2>&1'] },
-  { key: 'firefox', command: 'firefox --version 2>&1' },
+  { key: 'chromium', command: 'chromium --version 2>&1', fallbacks: ['chromium-browser --version 2>&1', "ls ~/.cache/ms-playwright/ 2>/dev/null | grep -oE 'chromium-[0-9]+' | head -1"] },
+  { key: 'firefox', command: 'firefox --version 2>&1', fallbacks: ["ls ~/.cache/ms-playwright/ 2>/dev/null | grep -oE 'firefox-[0-9]+' | head -1"] },
   { key: 'msedge', command: 'microsoft-edge --version 2>&1', fallbacks: ['microsoft-edge-stable --version 2>&1'] },
   { key: 'webkit', command: "ls ~/.cache/ms-playwright/ 2>/dev/null | grep -oE 'webkit-[0-9]+' | head -1" },
 
@@ -109,7 +500,7 @@ const VERSION_COMMANDS = [
   { key: 'gpp', command: 'g++ --version 2>&1 | head -n1' },
   { key: 'clang', command: 'clang --version 2>&1 | head -n1' },
   { key: 'llvm', command: 'llvm-config --version 2>&1' },
-  { key: 'lld', command: 'lld --version 2>&1 | head -n1' },
+  { key: 'lld', command: 'ld.lld --version 2>&1 | head -n1', fallbacks: ['lld --version 2>&1 | head -n1'] },
   { key: 'make', command: 'make --version 2>&1 | head -n1' },
   { key: 'cmake', command: 'cmake --version 2>&1 | head -n1' },
 
@@ -139,7 +530,7 @@ const VERSION_COMMANDS = [
   { key: 'unzip', command: 'unzip -v 2>&1 | head -n1' },
   { key: 'expect', command: 'expect -version 2>&1' },
   { key: 'screen', command: 'screen --version 2>&1' },
-  { key: 'xvfb', command: 'Xvfb -version 2>&1 | head -n1', fallbacks: ['dpkg -l xvfb 2>/dev/null | grep xvfb | head -1'] },
+  { key: 'xvfb', command: 'dpkg -l xvfb 2>/dev/null | grep "^ii" | head -1', fallbacks: ['Xvfb -version 2>&1 | head -n1'] },
 ];
 
 /**
@@ -353,14 +744,17 @@ export async function getVersionInfo(verbose = false, processVersion = null) {
 }
 
 /**
- * Helper to add version line if version exists
+ * Helper to add version line if version exists.
+ * Uses parseVersion() to normalize raw output into uniform format.
  * @param {string[]} lines - Array to push to
  * @param {string} label - Display label
  * @param {string|null} version - Version string or null
+ * @param {string} [key] - Tool key for version parser lookup
  */
-function addVersionLine(lines, label, version) {
+function addVersionLine(lines, label, version, key) {
   if (version) {
-    lines.push(`• ${label}: \`${version}\``);
+    const display = key ? parseVersion(key, version) : version;
+    lines.push(`• ${label}: \`${display}\``);
   }
 }
 
@@ -384,13 +778,13 @@ export function formatVersionMessage(versions) {
 
   // === AI Agents (--tool options) ===
   const agentLines = [];
-  addVersionLine(agentLines, 'Claude Code', versions.claudeCode);
-  addVersionLine(agentLines, 'Agent CLI', versions.agent);
-  addVersionLine(agentLines, 'OpenAI Codex', versions.codex);
-  addVersionLine(agentLines, 'OpenCode', versions.opencode);
-  addVersionLine(agentLines, 'Qwen Code', versions.qwenCode);
-  addVersionLine(agentLines, 'Gemini CLI', versions.gemini);
-  addVersionLine(agentLines, 'GitHub Copilot', versions.copilot);
+  addVersionLine(agentLines, 'Claude Code', versions.claudeCode, 'claudeCode');
+  addVersionLine(agentLines, 'Agent CLI', versions.agent, 'agent');
+  addVersionLine(agentLines, 'OpenAI Codex', versions.codex, 'codex');
+  addVersionLine(agentLines, 'OpenCode', versions.opencode, 'opencode');
+  addVersionLine(agentLines, 'Qwen Code', versions.qwenCode, 'qwenCode');
+  addVersionLine(agentLines, 'Gemini CLI', versions.gemini, 'gemini');
+  addVersionLine(agentLines, 'GitHub Copilot', versions.copilot, 'copilot');
 
   if (agentLines.length > 0) {
     lines.push('');
@@ -402,7 +796,7 @@ export function formatVersionMessage(versions) {
   const jsLines = [];
   addVersionLine(jsLines, 'Node.js', versions.node);
   addVersionLine(jsLines, 'Bun', versions.bun);
-  addVersionLine(jsLines, 'Deno', versions.deno);
+  addVersionLine(jsLines, 'Deno', versions.deno, 'deno');
   addVersionLine(jsLines, 'NPM', versions.npm);
   addVersionLine(jsLines, 'NVM', versions.nvm);
 
@@ -414,8 +808,8 @@ export function formatVersionMessage(versions) {
 
   // === Python ===
   const pythonLines = [];
-  addVersionLine(pythonLines, 'Python', versions.python);
-  addVersionLine(pythonLines, 'Pyenv', versions.pyenv);
+  addVersionLine(pythonLines, 'Python', versions.python, 'python');
+  addVersionLine(pythonLines, 'Pyenv', versions.pyenv, 'pyenv');
 
   if (pythonLines.length > 0) {
     lines.push('');
@@ -425,8 +819,8 @@ export function formatVersionMessage(versions) {
 
   // === Rust ===
   const rustLines = [];
-  addVersionLine(rustLines, 'Rustc', versions.rust);
-  addVersionLine(rustLines, 'Cargo', versions.cargo);
+  addVersionLine(rustLines, 'Rustc', versions.rust, 'rust');
+  addVersionLine(rustLines, 'Cargo', versions.cargo, 'cargo');
 
   if (rustLines.length > 0) {
     lines.push('');
@@ -436,7 +830,7 @@ export function formatVersionMessage(versions) {
 
   // === Java ===
   const javaLines = [];
-  addVersionLine(javaLines, 'Java', versions.java);
+  addVersionLine(javaLines, 'Java', versions.java, 'java');
   addVersionLine(javaLines, 'SDKMAN', versions.sdkman);
 
   if (javaLines.length > 0) {
@@ -449,14 +843,14 @@ export function formatVersionMessage(versions) {
   if (versions.go) {
     lines.push('');
     lines.push('*🔷 Go*');
-    addVersionLine(lines, 'Go', versions.go);
+    addVersionLine(lines, 'Go', versions.go, 'go');
   }
 
   // === PHP ===
   if (versions.php) {
     lines.push('');
     lines.push('*🐘 PHP*');
-    addVersionLine(lines, 'PHP', versions.php);
+    addVersionLine(lines, 'PHP', versions.php, 'php');
   }
 
   // === .NET ===
@@ -469,7 +863,7 @@ export function formatVersionMessage(versions) {
   // === Perl ===
   const perlLines = [];
   addVersionLine(perlLines, 'Perl', versions.perl);
-  addVersionLine(perlLines, 'Perlbrew', versions.perlbrew);
+  addVersionLine(perlLines, 'Perlbrew', versions.perlbrew, 'perlbrew');
 
   if (perlLines.length > 0) {
     lines.push('');
@@ -479,9 +873,9 @@ export function formatVersionMessage(versions) {
 
   // === OCaml/Rocq ===
   const ocamlLines = [];
-  addVersionLine(ocamlLines, 'OCaml', versions.ocaml);
+  addVersionLine(ocamlLines, 'OCaml', versions.ocaml, 'ocaml');
   addVersionLine(ocamlLines, 'Opam', versions.opam);
-  addVersionLine(ocamlLines, 'Rocq/Coq', versions.rocq);
+  addVersionLine(ocamlLines, 'Rocq/Coq', versions.rocq, 'rocq');
 
   if (ocamlLines.length > 0) {
     lines.push('');
@@ -491,8 +885,8 @@ export function formatVersionMessage(versions) {
 
   // === Lean ===
   const leanLines = [];
-  addVersionLine(leanLines, 'Lean', versions.lean);
-  addVersionLine(leanLines, 'Elan', versions.elan);
+  addVersionLine(leanLines, 'Lean', versions.lean, 'lean');
+  addVersionLine(leanLines, 'Elan', versions.elan, 'elan');
   addVersionLine(leanLines, 'Lake', versions.lake);
 
   if (leanLines.length > 0) {
@@ -503,8 +897,8 @@ export function formatVersionMessage(versions) {
 
   // === Ruby ===
   const rubyLines = [];
-  addVersionLine(rubyLines, 'Ruby', versions.ruby);
-  addVersionLine(rubyLines, 'Rbenv', versions.rbenv);
+  addVersionLine(rubyLines, 'Ruby', versions.ruby, 'ruby');
+  addVersionLine(rubyLines, 'Rbenv', versions.rbenv, 'rbenv');
 
   if (rubyLines.length > 0) {
     lines.push('');
@@ -516,34 +910,34 @@ export function formatVersionMessage(versions) {
   if (versions.kotlin) {
     lines.push('');
     lines.push('*🟣 Kotlin*');
-    addVersionLine(lines, 'Kotlin', versions.kotlin);
+    addVersionLine(lines, 'Kotlin', versions.kotlin, 'kotlin');
   }
 
   // === Swift ===
   if (versions.swift) {
     lines.push('');
     lines.push('*🦅 Swift*');
-    addVersionLine(lines, 'Swift', versions.swift);
+    addVersionLine(lines, 'Swift', versions.swift, 'swift');
   }
 
   // === R ===
   if (versions.r) {
     lines.push('');
     lines.push('*📊 R*');
-    addVersionLine(lines, 'R', versions.r);
+    addVersionLine(lines, 'R', versions.r, 'r');
   }
 
   // === C/C++ ===
   const cppLines = [];
-  addVersionLine(cppLines, 'GCC', versions.gcc);
-  addVersionLine(cppLines, 'G++', versions.gpp);
-  addVersionLine(cppLines, 'Clang', versions.clang);
+  addVersionLine(cppLines, 'GCC', versions.gcc, 'gcc');
+  addVersionLine(cppLines, 'G++', versions.gpp, 'gpp');
+  addVersionLine(cppLines, 'Clang', versions.clang, 'clang');
   addVersionLine(cppLines, 'LLVM', versions.llvm);
-  addVersionLine(cppLines, 'LLD', versions.lld);
-  addVersionLine(cppLines, 'Make', versions.make);
-  addVersionLine(cppLines, 'CMake', versions.cmake);
-  addVersionLine(cppLines, 'NASM', versions.nasm);
-  addVersionLine(cppLines, 'FASM', versions.fasm);
+  addVersionLine(cppLines, 'LLD', versions.lld, 'lld');
+  addVersionLine(cppLines, 'Make', versions.make, 'make');
+  addVersionLine(cppLines, 'CMake', versions.cmake, 'cmake');
+  addVersionLine(cppLines, 'NASM', versions.nasm, 'nasm');
+  addVersionLine(cppLines, 'FASM', versions.fasm, 'fasm');
 
   if (cppLines.length > 0) {
     lines.push('');
@@ -553,10 +947,10 @@ export function formatVersionMessage(versions) {
 
   // === Browsers ===
   const browserLines = [];
-  addVersionLine(browserLines, 'Google Chrome', versions.chrome);
-  addVersionLine(browserLines, 'Chromium', versions.chromium);
-  addVersionLine(browserLines, 'Firefox', versions.firefox);
-  addVersionLine(browserLines, 'Microsoft Edge', versions.msedge);
+  addVersionLine(browserLines, 'Google Chrome', versions.chrome, 'chrome');
+  addVersionLine(browserLines, 'Chromium', versions.chromium, 'chromium');
+  addVersionLine(browserLines, 'Firefox', versions.firefox, 'firefox');
+  addVersionLine(browserLines, 'Microsoft Edge', versions.msedge, 'msedge');
   addVersionLine(browserLines, 'WebKit', versions.webkit);
 
   if (browserLines.length > 0) {
@@ -567,15 +961,15 @@ export function formatVersionMessage(versions) {
 
   // === Browser Automation ===
   const browserAutoLines = [];
-  addVersionLine(browserAutoLines, 'Playwright', versions.playwright);
-  addVersionLine(browserAutoLines, 'Playwright Test', versions.playwrightTest);
-  addVersionLine(browserAutoLines, 'Playwright MCP', versions.playwrightMcp);
-  if (versions.playwrightMcpStatus) {
-    browserAutoLines.push(`• Playwright MCP in Claude Code: \`${versions.playwrightMcpStatus}\``);
-  } else if (versions.playwrightMcp) {
-    browserAutoLines.push('• Playwright MCP in Claude Code: `not configured`');
+  addVersionLine(browserAutoLines, 'Playwright', versions.playwright, 'playwright');
+  addVersionLine(browserAutoLines, 'Playwright Test', versions.playwrightTest, 'playwrightTest');
+  // Playwright MCP: show version with Claude Code connection status inline
+  if (versions.playwrightMcp) {
+    const mcpVersion = parseVersion('playwrightMcp', versions.playwrightMcp);
+    const claudeStatus = versions.playwrightMcpStatus ? 'connected' : 'not connected';
+    browserAutoLines.push(`• Playwright MCP: \`${mcpVersion} | Claude Code: ${claudeStatus}\``);
   }
-  addVersionLine(browserAutoLines, 'Puppeteer Browsers', versions.puppeteerBrowsers);
+  addVersionLine(browserAutoLines, 'Puppeteer Browsers', versions.puppeteerBrowsers, 'puppeteerBrowsers');
 
   if (browserAutoLines.length > 0) {
     lines.push('');
@@ -585,17 +979,17 @@ export function formatVersionMessage(versions) {
 
   // === Development Tools ===
   const toolLines = [];
-  addVersionLine(toolLines, 'Git', versions.git);
-  addVersionLine(toolLines, 'GitHub CLI', versions.gh);
-  addVersionLine(toolLines, 'GitLab CLI', versions.glab);
-  addVersionLine(toolLines, 'Homebrew', versions.brew);
-  addVersionLine(toolLines, 'cURL', versions.curl);
-  addVersionLine(toolLines, 'Wget', versions.wget);
-  addVersionLine(toolLines, 'Zip', versions.zip);
-  addVersionLine(toolLines, 'Unzip', versions.unzip);
-  addVersionLine(toolLines, 'Expect', versions.expect);
-  addVersionLine(toolLines, 'Screen', versions.screen);
-  addVersionLine(toolLines, 'Xvfb', versions.xvfb);
+  addVersionLine(toolLines, 'Git', versions.git, 'git');
+  addVersionLine(toolLines, 'GitHub CLI', versions.gh, 'gh');
+  addVersionLine(toolLines, 'GitLab CLI', versions.glab, 'glab');
+  addVersionLine(toolLines, 'Homebrew', versions.brew, 'brew');
+  addVersionLine(toolLines, 'cURL', versions.curl, 'curl');
+  addVersionLine(toolLines, 'Wget', versions.wget, 'wget');
+  addVersionLine(toolLines, 'Zip', versions.zip, 'zip');
+  addVersionLine(toolLines, 'Unzip', versions.unzip, 'unzip');
+  addVersionLine(toolLines, 'Expect', versions.expect, 'expect');
+  addVersionLine(toolLines, 'Screen', versions.screen, 'screen');
+  addVersionLine(toolLines, 'Xvfb', versions.xvfb, 'xvfb');
 
   if (toolLines.length > 0) {
     lines.push('');
@@ -616,4 +1010,5 @@ export function formatVersionMessage(versions) {
 export default {
   getVersionInfo,
   formatVersionMessage,
+  parseVersion,
 };