@link-assistant/hive-mind 1.46.1 → 1.46.3

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # @link-assistant/hive-mind
 
+## 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
+
+- 37daeb7: Auto-recover from non-fork repositories during fork validation (Issue #1518)
+  - When a repository exists but is NOT a proper GitHub fork (or has wrong parent), safely auto-recover by comparing commits against upstream first — only delete and re-fork if no additional commits would be lost
+  - Add verbose logging of fork commands for debugging non-fork creation scenarios
+  - Add post-creation fork validation to detect non-fork repos immediately after `gh repo fork`
+  - Report non-fork creation to Sentry for monitoring
+  - Add `--allow-force-non-fork-repository-deletion` flag to force deletion even when additional commits would be lost
+  - Add case study documenting the root cause analysis of konard/MixaByk1996-elements-app
+  - Document all previously undocumented solve options in CONFIGURATION.md (12 options including --allow-force-non-fork-repository-deletion)
+  - Add CI/CD test to verify documentation stays in sync with code options (prevents drift)
+
 ## 1.46.1
 
 ### Patch Changes

package/package.json

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

package/src/option-suggestions.lib.mjs

@@ -199,6 +199,7 @@ const KNOWN_OPTION_NAMES = [
   'only-prepare-command',
   'auto-merge-default-branch-to-pull-request-branch',
   'allow-fork-divergence-resolution-using-force-push-with-lease',
+  'allow-force-non-fork-repository-deletion',
   'allow-to-push-to-contributors-pull-requests-as-maintainer',
   'prefix-fork-name-with-owner-name',
   'auto-restart-max-iterations',

package/src/solve.config.lib.mjs

@@ -273,6 +273,11 @@ export const SOLVE_OPTION_DEFINITIONS = {
     description: 'Allow automatic force-push (--force-with-lease) when fork diverges from upstream (DANGEROUS: can overwrite fork history)',
     default: false,
   },
+  'allow-force-non-fork-repository-deletion': {
+    type: 'boolean',
+    description: 'Allow deletion of non-fork repositories even when they contain additional commits that would be lost (DANGEROUS: data loss possible)',
+    default: false,
+  },
   'allow-to-push-to-contributors-pull-requests-as-maintainer': {
     type: 'boolean',
     description: 'When continuing a fork PR as a maintainer, attempt to push directly to the contributor\'s fork if "Allow edits by maintainers" is enabled. Requires --auto-fork to be enabled.',

package/src/solve.repository.lib.mjs

@@ -490,78 +490,77 @@ export const setupRepository = async (argv, owner, repo, forkOwner = null, issue
 
       const forkValidation = await validateForkParent(existingForkName, `${owner}/${repo}`);
 
-      if (!forkValidation.isValid) {
+      if (forkValidation.isValid) {
+        // Fork is valid — use it
+        await log(`${formatAligned('✅', 'Fork parent validated:', `${forkValidation.parent}`)}`);
+        repoToClone = existingForkName;
+        forkedRepo = existingForkName;
+        upstreamRemote = `${owner}/${repo}`;
+      } else if (forkValidation.isNetworkError) {
         // Issue #1311: Handle network errors separately from fork mismatch errors
-        if (forkValidation.isNetworkError) {
-          await log('');
-          await log(`${formatAligned('❌', 'NETWORK ERROR DURING FORK VALIDATION', '')}`, { level: 'error' });
-          await log('');
-          await log('  🔍 What happened:');
-          await log(`     Failed to connect to GitHub API while validating fork.`);
-          await log(`     Error: ${forkValidation.error}`);
-          await log('');
-          await log('  💡 This is likely a temporary network issue. You can:');
-          await log('     1. Wait a moment and try again');
-          await log('     2. Check your internet connection');
-          await log('     3. Check GitHub status: https://www.githubstatus.com/');
-          await log('');
-          await log('     Or use --no-fork to skip fork validation if you have write access.');
-          await log('');
-          await safeExit(1, 'Network error during fork validation - please retry');
-        }
-
-        // Fork parent mismatch detected - this prevents issue #967
         await log('');
-        await log(`${formatAligned('❌', 'FORK PARENT MISMATCH DETECTED', '')}`, { level: 'error' });
+        await log(`${formatAligned('❌', 'NETWORK ERROR DURING FORK VALIDATION', '')}`, { level: 'error' });
         await log('');
         await log('  🔍 What happened:');
-        if (!forkValidation.isFork) {
-          await log(`     The repository ${existingForkName} is NOT a GitHub fork.`);
-          await log('     It may have been created by cloning and pushing instead of forking.');
-        } else {
-          await log(`     Your fork ${existingForkName} was created from an intermediate fork,`);
-          await log(`     not directly from the target repository ${owner}/${repo}.`);
-        }
-        await log('');
-        await log('  📦 Fork relationship:');
-        await log(`     • Your fork: ${existingForkName}`);
-        await log(`     • Fork parent: ${forkValidation.parent || 'N/A (not a fork)'}`);
-        await log(`     • Fork source (root): ${forkValidation.source || 'N/A'}`);
-        await log(`     • Expected parent: ${owner}/${repo}`);
-        await log('');
-        await log('  ⚠️  Why this is a problem:');
-        await log('     When a fork is created from an intermediate fork (a "fork of a fork"),');
-        await log('     any commits that exist in the intermediate fork but not in the target');
-        await log('     repository will be included in your pull requests. This can result in');
-        await log('     pull requests with hundreds or thousands of unexpected commits.');
+        await log(`     Failed to connect to GitHub API while validating fork.`);
+        await log(`     Error: ${forkValidation.error}`);
         await log('');
-        await log('  📖 Case study: See issue #967');
-        await log('     A fork created from veb86/zcadvelecAI (which had 1,678 extra commits)');
-        await log('     instead of zamtmn/zcad resulted in a PR with 1,681 commits');
-        await log('     instead of the expected 3 commits.');
+        await log('  💡 This is likely a temporary network issue. You can:');
+        await log('     1. Wait a moment and try again');
+        await log('     2. Check your internet connection');
+        await log('     3. Check GitHub status: https://www.githubstatus.com/');
         await log('');
-        await log('  💡 How to fix:');
+        await log('     Or use --no-fork to skip fork validation if you have write access.');
         await log('');
-        await log('     Option 1: Delete the problematic fork and create a fresh one');
-        await log(`        gh repo delete ${existingForkName}`);
-        await log(`        Then run this command again to create a proper fork of ${owner}/${repo}`);
-        await log('');
-        await log('     Option 2: Use --prefix-fork-name-with-owner-name to create a new fork');
-        await log(`        This creates a fork named ${currentUser}/${owner}-${repo} instead`);
-        await log(`        ./solve.mjs "${issueUrl || `https://github.com/${owner}/${repo}/issues/<number>`}" --prefix-fork-name-with-owner-name --fork`);
-        await log('');
-        await log('     Option 3: Work directly on the repository (if you have write access)');
-        await log(`        ./solve.mjs "${issueUrl || `https://github.com/${owner}/${repo}/issues/<number>`}" --no-fork`);
+        await safeExit(1, 'Network error during fork validation - please retry');
+      } else {
+        // Issue #1518: Auto-recovery — delete non-fork/mismatched repo and re-fork, but only if no commits would be lost
         await log('');
-
-        await safeExit(1, 'Fork parent mismatch - fork was created from intermediate fork');
+        await log(`${formatAligned('⚠️', 'FORK PARENT MISMATCH DETECTED', '')}`, { level: 'warning' });
+        const detail = !forkValidation.isFork ? `Repository ${existingForkName} is NOT a GitHub fork (see issue #1518)` : `Fork ${existingForkName} was created from ${forkValidation.parent} instead of ${owner}/${repo} (see issue #967)`;
+        await log(`${formatAligned('', '', detail)}`);
+        await log(`${formatAligned('', '', `Fork parent: ${forkValidation.parent || 'N/A (not a fork)'}, source: ${forkValidation.source || 'N/A'}, expected: ${owner}/${repo}`)}`);
+        // Safety check: compare commits before deleting to avoid data loss
+        await log(`${formatAligned('🔍', 'Safety check:', 'Comparing commits against upstream...')}`);
+        let safeToDelete = false;
+        try {
+          const cmp = await $`gh api repos/${owner}/${repo}/compare/${owner}:HEAD...${existingForkName.split('/')[0]}:HEAD --jq '.ahead_by' 2>&1`;
+          if (cmp.code === 0 && parseInt(cmp.stdout.toString().trim(), 10) === 0) {
+            await log(`${formatAligned('✅', 'Safe to delete:', 'No additional commits in non-fork repository')}`);
+            safeToDelete = true;
+          } else if (cmp.code === 0) {
+            await log(`${formatAligned('⚠️', 'UNSAFE:', `Repository has ${cmp.stdout.toString().trim()} commit(s) ahead of upstream that would be lost`)}`, { level: 'warning' });
+          } else {
+            await log(`${formatAligned('⚠️', 'Compare failed:', ((cmp.stderr?.toString() || '') + (cmp.stdout?.toString() || '')).split('\n')[0])}`, { level: 'warning' });
+          }
+        } catch (e) {
+          await log(`${formatAligned('⚠️', 'Compare error:', e.message)}`, { level: 'warning' });
+        }
+        if (!safeToDelete) {
+          if (argv.allowForceNonForkRepositoryDeletion) {
+            await log(`${formatAligned('⚠️', 'Force deletion ENABLED:', '--allow-force-non-fork-repository-deletion — proceeding despite potential data loss')}`, { level: 'warning' });
+            safeToDelete = true;
+          } else {
+            await log(`  💡 Manual fix required: back up work, then: gh repo delete ${existingForkName} --yes`);
+            await log(`     Then run this command again to create a proper fork of ${owner}/${repo}`);
+            await log(`  🔧 Or force deletion (DANGEROUS): solve ${argv.url || argv['issue-url'] || argv._[0] || '<issue-url>'} --allow-force-non-fork-repository-deletion`);
+            await safeExit(1, 'Auto-recovery skipped - repository may contain commits that would be lost');
+          }
+        }
+        await log(`${formatAligned('🔄', 'Auto-recovery:', 'Deleting non-fork repository and creating fresh fork...')}`);
+        const deleteResult = await $`gh repo delete ${existingForkName} --yes 2>&1`;
+        if (deleteResult.code !== 0) {
+          const delOut = (deleteResult.stderr?.toString() || '') + (deleteResult.stdout?.toString() || '');
+          await log(`${formatAligned('❌', 'Delete failed:', delOut.split('\n')[0])}`, { level: 'error' });
+          await log(`  💡 Manual fix: gh repo delete ${existingForkName} --yes, then re-run`);
+          await safeExit(1, 'Auto-recovery failed - could not delete problematic repository');
+        }
+        await log(`${formatAligned('✅', 'Deleted:', existingForkName)}`);
+        existingForkName = null; // Fall through to fork creation below
       }
+    }
 
-      await log(`${formatAligned('✅', 'Fork parent validated:', `${forkValidation.parent}`)}`);
-      repoToClone = existingForkName;
-      forkedRepo = existingForkName;
-      upstreamRemote = `${owner}/${repo}`;
-    } else {
+    if (!existingForkName) {
       // Need to create fork with retry logic for concurrent scenarios
       await log(`${formatAligned('🔄', 'Creating fork...', '')}`);
 
@@ -575,19 +574,18 @@ export const setupRepository = async (argv, owner, repo, forkOwner = null, issue
       let actualForkName = `${currentUser}/${defaultForkName}`;
 
       for (let attempt = 1; attempt <= maxForkRetries; attempt++) {
-        // Try to create fork with optional custom name
         let forkResult;
+        // Issue #1518: Log the exact fork command for debugging non-fork creation scenarios
+        if (argv.verbose) await log(`${formatAligned('🔧', 'Fork command:', argv.prefixForkNameWithOwnerName ? `gh repo fork ${owner}/${repo} --fork-name ${owner}-${repo} --clone=false` : `gh repo fork ${owner}/${repo} --clone=false`)}`);
         if (argv.prefixForkNameWithOwnerName) {
-          // Use --fork-name flag to create fork with owner prefix
           forkResult = await $`gh repo fork ${owner}/${repo} --fork-name ${owner}-${repo} --clone=false 2>&1`;
         } else {
-          // Standard fork creation (no custom name)
           forkResult = await $`gh repo fork ${owner}/${repo} --clone=false 2>&1`;
         }
 
         // Always capture output to parse actual fork name
         const forkOutput = (forkResult.stderr ? forkResult.stderr.toString() : '') + (forkResult.stdout ? forkResult.stdout.toString() : '');
-
+        if (argv.verbose) await log(`${formatAligned('🔧', 'Fork output:', forkOutput.split('\n')[0] || '(empty)')}`); // Issue #1518
         // Parse actual fork name from output (e.g., "konard/netkeep80-jsonRVM already exists")
         // GitHub may create forks with modified names to avoid conflicts
         // Use regex that won't match domain names like "github.com/user" -> "com/user"
@@ -792,11 +790,20 @@ Thank you!`;
           await safeExit(1, 'Repository setup failed');
         }
 
-        // Wait a moment for fork to be fully ready
         if (forkCreated) {
+          // Wait a moment for fork to be fully ready
           await log(`${formatAligned('⏳', 'Waiting:', 'For fork to be fully ready...')}`);
           await new Promise(resolve => setTimeout(resolve, 3000));
         }
+        // Issue #1518: Validate fork parent after creation/discovery to detect non-fork repos early (covers concurrent worker scenarios too)
+        await log(`${formatAligned('🔍', 'Validating fork parent...', '')}`);
+        const pcv = await validateForkParent(actualForkName, `${owner}/${repo}`);
+        if (pcv.isValid) {
+          await log(`${formatAligned('✅', 'Fork parent validated:', `${pcv.parent}`)}`);
+        } else if (!pcv.isNetworkError) {
+          await log(`${formatAligned('⚠️', 'WARNING:', `Fork failed validation (possible gh CLI bug, see issue #1518): ${pcv.error}`)}`, { level: 'warning' });
+          reportError(new Error(`Fork created as non-fork: ${pcv.error}`), { context: 'fork_creation_validation', forkRepo: actualForkName, expectedUpstream: `${owner}/${repo}`, isFork: pcv.isFork, parent: pcv.parent, source: pcv.source });
+        }
       }
 
       repoToClone = actualForkName;

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,
 };