@link-assistant/hive-mind 1.46.2 → 1.46.4

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @link-assistant/hive-mind
 
+## 1.46.4
+
+### Patch Changes
+
+- a3bdea6: Fix CI/CD false positive for .gitkeep files using positive matching (Issue #1528).
+
+  Use consistent positive matching in detect-code-changes.mjs: "Files considered as code changes" now only shows files matching codePattern, so unknown file types like .gitkeep are naturally excluded without explicit exclusion rules. Add 40 unit tests covering the full detection pipeline.
+
+## 1.46.3
+
+### Patch Changes
+
+- c425744: Standardize /version output — strip OS/arch, normalize dates, enhance platform detection (Issue #1524)
+  - Strip OS/architecture info (e.g. x86_64-unknown-linux-gnu, linux/amd64) from version strings for cleaner output
+  - Normalize date formats to ISO (YYYY-MM-DD) across all version components
+  - Enhance platform detection for consistent environment reporting
+
 ## 1.46.2
 
 ### Patch Changes

package/package.json

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

package/src/version-info.lib.mjs

@@ -13,6 +13,89 @@ import { promisify } from 'util';
 
 const execAsync = promisify(exec);
 
+/**
+ * Month name/abbreviation to zero-padded number mapping
+ */
+const MONTH_MAP = {
+  jan: '01',
+  january: '01',
+  feb: '02',
+  february: '02',
+  mar: '03',
+  march: '03',
+  apr: '04',
+  april: '04',
+  may: '05',
+  jun: '06',
+  june: '06',
+  jul: '07',
+  july: '07',
+  aug: '08',
+  august: '08',
+  sep: '09',
+  september: '09',
+  oct: '10',
+  october: '10',
+  nov: '11',
+  november: '11',
+  dec: '12',
+  december: '12',
+};
+
+/**
+ * Normalize a date string to ISO format (YYYY-MM-DD).
+ * Handles formats like:
+ *   "20-Aug-23"       → "2023-08-20"
+ *   "20 April 2009"   → "2009-04-20"
+ *   "July 5th 2008"   → "2008-07-05"
+ *   "Jan 13 2026"     → "2026-01-13"
+ *   "2024-02-29"      → "2024-02-29" (passthrough)
+ * Returns the original string if parsing fails.
+ * @param {string} dateStr - Date string to normalize
+ * @returns {string} ISO date string or original
+ */
+export function normalizeDate(dateStr) {
+  if (!dateStr) return dateStr;
+  const s = dateStr.trim();
+
+  // Already ISO: YYYY-MM-DD
+  if (/^\d{4}-\d{2}-\d{2}$/.test(s)) return s;
+
+  // "DD-Mon-YY" (e.g. "20-Aug-23")
+  const dmy = s.match(/^(\d{1,2})-([A-Za-z]{3})-(\d{2})$/);
+  if (dmy) {
+    const month = MONTH_MAP[dmy[2].toLowerCase()];
+    if (month) {
+      const year = parseInt(dmy[3], 10);
+      const fullYear = year >= 70 ? `19${dmy[3]}` : `20${dmy[3]}`;
+      return `${fullYear}-${month}-${dmy[1].padStart(2, '0')}`;
+    }
+  }
+
+  // "DD Month YYYY" (e.g. "20 April 2009")
+  const dmY = s.match(/^(\d{1,2})\s+([A-Za-z]+)\s+(\d{4})$/);
+  if (dmY) {
+    const month = MONTH_MAP[dmY[2].toLowerCase()];
+    if (month) return `${dmY[3]}-${month}-${dmY[1].padStart(2, '0')}`;
+  }
+
+  // "Month DDth YYYY" or "Month DD YYYY" (e.g. "July 5th 2008", "Jan 13 2026")
+  const mdY = s.match(/^([A-Za-z]+)\s+(\d{1,2})(?:st|nd|rd|th)?\s+(\d{4})$/);
+  if (mdY) {
+    const month = MONTH_MAP[mdY[1].toLowerCase()];
+    if (month) return `${mdY[3]}-${month}-${mdY[2].padStart(2, '0')}`;
+  }
+
+  // "Month DD YYYY HH:MM:SS" (e.g. "Jan 13 2026 22:36:55")
+  const mdYt = s.match(/^([A-Za-z]+)\s+(\d{1,2})\s+(\d{4})\s+(\d{2}:\d{2}:\d{2})$/);
+  if (mdYt) {
+    const month = MONTH_MAP[mdYt[1].toLowerCase()];
+    if (month) return `${mdYt[3]}-${month}-${mdYt[2].padStart(2, '0')} ${mdYt[4]}`;
+  }
+
+  return s;
+}
+
 /**
  * Execute a command asynchronously and return its output, or null if it fails
  * @param {string} command - Command to execute
@@ -58,19 +141,30 @@ const VERSION_PARSERS = {
     const extra = m[2] ? m[2].trim().split(/\s+/) : [];
     return { version: m[1], extra };
   },
-  // go version go1.26.1 linux/amd64
+  // go version go1.26.1 linux/amd64 → strip platform/arch
   go: raw => {
-    const m = raw.match(/go([\d.]+(?:\S*)?)\s+(.*)/);
+    const m = raw.match(/go([\d.]+(?:\S*)?)/);
     if (!m) return null;
-    return { version: m[1], extra: [m[2].trim()] };
+    return { version: m[1], extra: [] };
   },
-  // PHP 8.3.30 (cli) (built: Jan 13 2026 22:36:55) (NTS)
+  // PHP 8.3.30 (cli) (built: Jan 13 2026 22:36:55) (NTS) → strip cli, normalize date
   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]);
+    for (const p of parts) {
+      const tag = p[1].trim();
+      // Skip "cli" — not meaningful for version display
+      if (tag === 'cli') continue;
+      // Normalize "built: Jan 13 2026 22:36:55" → "2026-01-13 22:36:55"
+      const built = tag.match(/^built:\s+(.+)$/);
+      if (built) {
+        tags.push(normalizeDate(built[1]));
+        continue;
+      }
+      tags.push(tag);
+    }
     return { version: m[1], extra: tags };
   },
   // openjdk version "21" 2023-09-19 LTS
@@ -79,27 +173,32 @@ const VERSION_PARSERS = {
     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 (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0 → use base version only
   gcc: raw => {
-    const m = raw.match(/^gcc\s+(?:\((\S+)\s+([\d.]+\S*)\)\s+)?([\d.]+)/);
+    const m = raw.match(/^gcc\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: [] };
+    return { version: m[1], extra: [] };
   },
-  // g++ (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0 — use full distro version
+  // g++ (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0 → use base version only
   gpp: raw => {
-    const m = raw.match(/^g\+\+\s+(?:\((\S+)\s+([\d.]+\S*)\)\s+)?([\d.]+)/);
+    const m = raw.match(/^g\+\+\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: [] };
+    return { version: m[1], extra: [] };
   },
-  // clang version 17.0.0 (https://github.com/... commit)
+  // clang version 17.0.0 (https://github.com/... 2e6139970eda) → strip URL, keep 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()] : [] };
+    if (m[2]) {
+      // Remove URLs, keep only hex commit hashes
+      const parts = m[2]
+        .trim()
+        .split(/\s+/)
+        .filter(p => !p.includes('://') && !p.includes('.git'));
+      const commitParts = parts.filter(p => /^[0-9a-f]{7,}$/i.test(p));
+      return { version: m[1], extra: commitParts };
+    }
+    return { version: m[1], extra: [] };
   },
   // LLD 17.0.0 (compatible with GNU linkers) — only version number matters
   lld: raw => {
@@ -113,34 +212,47 @@ const VERSION_PARSERS = {
     if (!m) return null;
     return { version: m[1], extra: [] };
   },
-  // ruby 3.4.9 (2026-03-11 revision 76cca827ab) +PRISM [x86_64-linux]
+  // ruby 3.4.9 (2026-03-11 revision 76cca827ab) +PRISM [x86_64-linux] → strip arch, reformat
   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());
+    if (m[2]) {
+      // Parse "2026-03-11 revision 76cca827ab" → commit, date
+      const revMatch = m[2].match(/^(\d{4}-\d{2}-\d{2})\s+revision\s+(\w+)$/);
+      if (revMatch) {
+        extra.push(revMatch[2]); // commit first
+        extra.push(revMatch[1]); // then date
+      } else {
+        extra.push(m[2].trim());
+      }
+    }
+    // Capture +PRISM or similar flags, but strip [arch] info
     const tail = m[3] ? m[3].trim() : '';
-    if (tail) extra.push(tail);
+    if (tail) {
+      const cleaned = tail.replace(/\[[\w-]+\]/g, '').trim();
+      if (cleaned) extra.push(cleaned);
+    }
     return { version: m[1], extra };
   },
-  // Kotlin version 2.3.20-release-208 (JRE 21+35-LTS)
+  // Kotlin version 2.3.20-release-208 (JRE 21+35-LTS) → strip -release-NNN suffix
   kotlin: raw => {
-    const m = raw.match(/^Kotlin\s+version\s+([\d.\-\w]+)\s*(?:\(([^)]+)\))?/);
+    const m = raw.match(/^Kotlin\s+version\s+([\d.]+)(?:-release-\d+)?\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 version 6.0.3 (swift-6.0.3-RELEASE) → strip redundant release tag
   swift: raw => {
-    const m = raw.match(/^Swift\s+version\s+([\d.]+(?:\.\d+)?)\s*(?:\(([^)]+)\))?/);
+    const m = raw.match(/^Swift\s+version\s+([\d.]+(?:\.\d+)?)/);
     if (!m) return null;
-    return { version: m[1], extra: m[2] ? [m[2].trim()] : [] };
+    return { version: m[1], extra: [] };
   },
-  // R version 4.3.3 (2024-02-29) -- "Angel Food Cake"
+  // R version 4.3.3 (2024-02-29) -- "Angel Food Cake" → normalize date
   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[2]) extra.push(normalizeDate(m[2]));
     if (m[3]) extra.push(m[3]);
     return { version: m[1], extra };
   },
@@ -162,11 +274,11 @@ const VERSION_PARSERS = {
     if (!m) return null;
     return { version: m[1], extra: [] };
   },
-  // curl 8.19.0 (x86_64-pc-linux-gnu) libcurl/8.19.0 ...
+  // curl 8.19.0 (x86_64-pc-linux-gnu) libcurl/8.19.0 ... → strip arch info
   curl: raw => {
-    const m = raw.match(/^curl\s+([\d.]+)\s*(?:\(([^)]+)\))?/);
+    const m = raw.match(/^curl\s+([\d.]+)/);
     if (!m) return null;
-    return { version: m[1], extra: m[2] ? [m[2]] : [] };
+    return { version: m[1], extra: [] };
   },
   // GNU Wget 1.21.4 built on linux-gnu.
   wget: raw => {
@@ -198,13 +310,13 @@ const VERSION_PARSERS = {
     if (!m) return null;
     return { version: m[1], extra: [] };
   },
-  // Screen version 4.09.01 (GNU) 20-Aug-23
+  // Screen version 4.09.01 (GNU) 20-Aug-23 → normalize date, strip GNU
   screen: raw => {
-    const m = raw.match(/^Screen\s+version\s+([\d.]+)\s*(?:\(([^)]+)\))?\s*(.*)/);
+    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());
+    const dateStr = m[2] ? m[2].trim() : '';
+    if (dateStr) extra.push(normalizeDate(dateStr));
     return { version: m[1], extra };
   },
   // expect version 5.45.4
@@ -232,7 +344,7 @@ const VERSION_PARSERS = {
     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 (version 4.29.0, x86_64-unknown-linux-gnu, commit abc123, Release) → strip arch/Release
   lean: raw => {
     const m = raw.match(/version\s+([\d.]+)(?:,\s*(.+?))\)?$/);
     if (!m) return null;
@@ -240,7 +352,13 @@ const VERSION_PARSERS = {
       ? m[2]
           .split(',')
           .map(s => s.trim().replace(/\)$/, ''))
-          .filter(Boolean)
+          .filter(s => {
+            if (!s) return false;
+            // Strip arch patterns and "Release"
+            if (/^\w+[-_]\w+[-_]\w+[-_]\w+$/.test(s)) return false;
+            if (s === 'Release') return false;
+            return true;
+          })
       : [];
     return { version: m[1], extra };
   },
@@ -268,7 +386,7 @@ const VERSION_PARSERS = {
     if (!m) return null;
     return { version: m[1], extra: [] };
   },
-  // deno 2.7.9 (stable, release, x86_64-unknown-linux-gnu)
+  // deno 2.7.9 (stable, release, x86_64-unknown-linux-gnu) → keep only channel (stable)
   deno: raw => {
     const m = raw.match(/^deno\s+([\d.]+)\s*(?:\(([^)]+)\))?/);
     if (!m) return null;
@@ -276,7 +394,7 @@ const VERSION_PARSERS = {
       ? m[2]
           .split(',')
           .map(s => s.trim())
-          .filter(Boolean)
+          .filter(s => s && s !== 'release' && !s.includes('-') && !s.includes('/'))
       : [];
     return { version: m[1], extra };
   },
@@ -304,11 +422,11 @@ const VERSION_PARSERS = {
     if (!m) return null;
     return { version: m[1], extra: [] };
   },
-  // 2.1.87 (Claude Code)
+  // 2.1.87 (Claude Code) → strip redundant product name
   claudeCode: raw => {
-    const m = raw.match(/([\d.]+)\s*(?:\(([^)]+)\))?/);
+    const m = raw.match(/([\d.]+)/);
     if (!m) return null;
-    return { version: m[1], extra: m[2] ? [m[2]] : [] };
+    return { version: m[1], extra: [] };
   },
   // GitHub Copilot CLI 1.0.14.\nRun 'copilot update'...
   copilot: raw => {
@@ -342,25 +460,26 @@ const VERSION_PARSERS = {
     if (!m) return null;
     return { version: m[1], extra: [] };
   },
-  // This is Zip 3.0 (July 5th 2008), by Info-ZIP.
+  // This is Zip 3.0 (July 5th 2008), by Info-ZIP. → normalize date
   zip: raw => {
     const m = raw.match(/Zip\s+([\d.]+)\s*(?:\(([^)]+)\))?/);
     if (!m) return null;
-    return { version: m[1], extra: m[2] ? [m[2]] : [] };
+    return { version: m[1], extra: m[2] ? [normalizeDate(m[2])] : [] };
   },
-  // UnZip 6.00 of 20 April 2009, by Debian.
+  // UnZip 6.00 of 20 April 2009, by Debian. → normalize date
   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()] : [] };
+    return { version: m[1], extra: m[2] ? [normalizeDate(m[2].trim())] : [] };
   },
-  // ii  xvfb  2:21.1.12-1ubuntu1.5  amd64  Virtual Framebuffer...
+  // ii  xvfb  2:21.1.12-1ubuntu1.5  amd64  Virtual Framebuffer... → base version only
   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+:/, '');
+      // Then strip distro suffix (e.g. "21.1.12-1ubuntu1.5" -> "21.1.12")
+      const ver = dpkg[1].replace(/^\d+:/, '').replace(/-.*$/, '');
       return { version: ver, extra: [] };
     }
     // X.Org X Server version output (if it ever works)
@@ -559,6 +678,95 @@ async function executeVersionCommand(cmdDef, verbose) {
   return { key: cmdDef.key, value: result };
 }
 
+/**
+ * Map of process.arch values to human-friendly architecture names
+ */
+const ARCH_NAMES = {
+  x64: 'AMD64 (x86-64)',
+  arm64: 'ARM64 (aarch64)',
+  arm: 'ARM32',
+  ia32: 'x86 (IA-32)',
+  mips: 'MIPS',
+  mipsel: 'MIPS (LE)',
+  ppc64: 'PowerPC 64',
+  s390x: 's390x',
+  riscv64: 'RISC-V 64',
+};
+
+/**
+ * Detect detailed platform information: environment type, OS, architecture, kernel.
+ * @param {boolean} verbose - Enable verbose logging
+ * @returns {Promise<{environment: string, arch: string, os: string, kernel: string}>}
+ */
+async function detectPlatformInfo(verbose) {
+  const info = { environment: '', arch: '', os: '', kernel: '' };
+
+  // Architecture
+  info.arch = ARCH_NAMES[process.arch] || process.arch;
+
+  // Kernel
+  const uname = await execCommandAsync('uname -r 2>/dev/null');
+  if (uname) {
+    info.kernel = `Linux ${uname}`;
+  } else if (process.platform === 'darwin') {
+    const darwinVer = await execCommandAsync('uname -r 2>/dev/null');
+    info.kernel = darwinVer ? `Darwin ${darwinVer}` : 'Darwin';
+  } else if (process.platform === 'win32') {
+    info.kernel = 'Windows NT';
+  }
+
+  // OS detection
+  if (process.platform === 'linux') {
+    // Try /etc/os-release for distro info
+    const osRelease = await execCommandAsync('cat /etc/os-release 2>/dev/null');
+    if (osRelease) {
+      const nameMatch = osRelease.match(/^PRETTY_NAME="?([^"\n]+)"?/m);
+      if (nameMatch) {
+        info.os = nameMatch[1];
+      } else {
+        const idMatch = osRelease.match(/^ID="?([^"\n]+)"?/m);
+        const versionMatch = osRelease.match(/^VERSION_ID="?([^"\n]+)"?/m);
+        if (idMatch) {
+          info.os = versionMatch ? `${idMatch[1]} ${versionMatch[1]}` : idMatch[1];
+        }
+      }
+    }
+    if (!info.os) info.os = 'Linux';
+  } else if (process.platform === 'darwin') {
+    const swVers = await execCommandAsync('sw_vers -productVersion 2>/dev/null');
+    info.os = swVers ? `macOS ${swVers}` : 'macOS';
+  } else if (process.platform === 'win32') {
+    info.os = 'Windows';
+  } else {
+    info.os = process.platform;
+  }
+
+  // Environment detection: docker container, VM, or host
+  const isDocker = await execCommandAsync('cat /proc/1/cgroup 2>/dev/null | grep -qi docker && echo docker || test -f /.dockerenv && echo docker || echo no');
+  if (isDocker && isDocker.trim() === 'docker') {
+    info.environment = 'docker container';
+  } else {
+    // Check for VM/hypervisor
+    const systemdDetect = await execCommandAsync('systemd-detect-virt 2>/dev/null');
+    if (systemdDetect && systemdDetect !== 'none') {
+      info.environment = `virtual machine (${systemdDetect})`;
+    } else {
+      const dmi = await execCommandAsync('cat /sys/class/dmi/id/product_name 2>/dev/null');
+      if (dmi && /virtual|vmware|kvm|qemu|hyper-v|xen|bochs/i.test(dmi)) {
+        info.environment = `virtual machine`;
+      } else {
+        info.environment = 'host machine';
+      }
+    }
+  }
+
+  if (verbose) {
+    console.log(`[VERBOSE] Platform detection: ${JSON.stringify(info)}`);
+  }
+
+  return info;
+}
+
 /**
  * Get comprehensive version information for all components
  * Uses Promise.all for parallel execution (issue #1320)
@@ -595,12 +803,16 @@ export async function getVersionInfo(verbose = false, processVersion = null) {
       console.log(`[VERBOSE] Node.js version: ${versions.node}`);
     }
 
-    // Platform information
-    const platform = process.platform;
-    const arch = process.arch;
-    versions.platform = `${platform} (${arch})`;
+    // Platform information — detailed detection
+    const platformInfo = await detectPlatformInfo(verbose);
+    versions.platformEnvironment = platformInfo.environment;
+    versions.platformArch = platformInfo.arch;
+    versions.platformOs = platformInfo.os;
+    versions.platformKernel = platformInfo.kernel;
+    // Keep legacy field for backward compat
+    versions.platform = platformInfo.os;
     if (verbose) {
-      console.log(`[VERBOSE] Platform: ${versions.platform}`);
+      console.log(`[VERBOSE] Platform: env=${platformInfo.environment}, arch=${platformInfo.arch}, os=${platformInfo.os}, kernel=${platformInfo.kernel}`);
     }
 
     // Check if process version differs from installed version (restart warning)
@@ -717,8 +929,12 @@ export async function getVersionInfo(verbose = false, processVersion = null) {
         screen: versions.screen,
         xvfb: versions.xvfb,
 
-        // Platform
+        // Platform (detailed)
         platform: versions.platform,
+        platformEnvironment: versions.platformEnvironment,
+        platformArch: versions.platformArch,
+        platformOs: versions.platformOs,
+        platformKernel: versions.platformKernel,
       },
       // Performance metrics
       gatherTimeMs: Date.now() - startTime,
@@ -941,7 +1157,7 @@ export function formatVersionMessage(versions) {
 
   if (cppLines.length > 0) {
     lines.push('');
-    lines.push('*🔨 C/C++/Assembly*');
+    lines.push('*🔨 C, C++, Assembly*');
     lines.push(...cppLines);
   }
 
@@ -997,11 +1213,22 @@ export function formatVersionMessage(versions) {
     lines.push(...toolLines);
   }
 
-  // === Platform ===
-  if (versions.platform) {
-    lines.push('');
-    lines.push('*💻 Platform*');
-    lines.push(`• System: \`${versions.platform}\``);
+  // === Platform (detailed) ===
+  {
+    const platformLines = [];
+    if (versions.platformEnvironment) platformLines.push(`• Environment: \`${versions.platformEnvironment}\``);
+    if (versions.platformArch) platformLines.push(`• Architecture: \`${versions.platformArch}\``);
+    if (versions.platformOs) platformLines.push(`• OS: \`${versions.platformOs}\``);
+    if (versions.platformKernel) platformLines.push(`• Kernel: \`${versions.platformKernel}\``);
+    // Fallback to legacy single-line format
+    if (platformLines.length === 0 && versions.platform) {
+      platformLines.push(`• System: \`${versions.platform}\``);
+    }
+    if (platformLines.length > 0) {
+      lines.push('');
+      lines.push('*💻 Platform*');
+      lines.push(...platformLines);
+    }
   }
 
   return lines.join('\n');
@@ -1011,4 +1238,5 @@ export default {
   getVersionInfo,
   formatVersionMessage,
   parseVersion,
+  normalizeDate,
 };