llm-checker 3.5.3 → 3.5.6

package/README.md

@@ -40,7 +40,7 @@ Choosing the right LLM for your hardware is complex. With thousands of model var
 |:---:|---|---|
 | **200+** | Dynamic Model Pool | Uses full scraped Ollama catalog/variants when available (with curated fallback) |
 | **4D** | Scoring Engine | Quality, Speed, Fit, Context — weighted by use case |
-| **Multi-GPU** | Hardware Detection | Apple Silicon, NVIDIA CUDA, AMD ROCm, Intel Arc, CPU |
+| **Multi-GPU** | Hardware Detection | Apple Silicon, NVIDIA CUDA, AMD ROCm, Intel Arc, CPU, integrated/dedicated inventory visibility |
 | **Calibrated** | Memory Estimation | Bytes-per-parameter formula validated against real Ollama sizes |
 | **Zero** | Native Dependencies | Pure JavaScript — works on any Node.js 16+ system |
 | **Optional** | SQLite Search | Install `sql.js` to unlock `sync`, `search`, and `smart-recommend` |
@@ -82,6 +82,13 @@ npm install -g llm-checker
 npx llm-checker hw-detect
 ```
 
+**Termux (Android):**
+```bash
+pkg update
+pkg install ollama
+npm install -g llm-checker
+```
+
 **Requirements:**
 - Node.js 16+ (any version: 16, 18, 20, 22, 24)
 - [Ollama](https://ollama.ai) installed for running models
@@ -508,6 +515,16 @@ Metal:
   Memory Bandwidth: 273GB/s
 ```
 
+On hybrid or integrated-only systems, `hw-detect` now also surfaces GPU topology explicitly:
+
+```
+Dedicated GPUs: NVIDIA GeForce RTX 4060
+Integrated GPUs: Intel Iris Xe Graphics
+Assist path: Integrated/shared-memory GPU detected, runtime remains CPU
+```
+
+This makes integrated GPUs visible even when the selected runtime backend is still CPU.
+
 ### `recommend` — Category Recommendations
 
 ```bash
@@ -531,19 +548,24 @@ Hardware Tier: HIGH | Models Analyzed: 205
 Coding:
    qwen2.5-coder:14b (14B)
    Score: 78/100
+   Fine-tuning: LoRA+QLoRA
    Command: ollama pull qwen2.5-coder:14b
 
 Reasoning:
    deepseek-r1:14b (14B)
    Score: 86/100
+   Fine-tuning: QLoRA
    Command: ollama pull deepseek-r1:14b
 
 Multimodal:
    llama3.2-vision:11b (11B)
    Score: 83/100
+   Fine-tuning: LoRA+QLoRA
    Command: ollama pull llama3.2-vision:11b
 ```
 
+`check`, `recommend`, and `ai-check` include a fine-tuning suitability label in output to help choose between Full FT, LoRA, and QLoRA paths.
+
 ### `search` — Model Search
 
 ```bash

package/bin/enhanced_cli.js

@@ -16,6 +16,7 @@ function getLLMChecker() {
 const { getLogger } = require('../src/utils/logger');
 const fs = require('fs');
 const path = require('path');
+const { normalizePlatform, isTermuxEnvironment } = require('../src/utils/platform');
 const {
     SUPPORTED_RUNTIMES,
     normalizeRuntime,
@@ -23,6 +24,7 @@ const {
     getRuntimeDisplayName,
     getRuntimeCommandSet
 } = require('../src/runtime/runtime-support');
+const { evaluateFineTuningSupport } = require('../src/models/fine-tuning-support');
 const { CalibrationManager } = require('../src/calibration/calibration-manager');
 const { SUPPORTED_CALIBRATION_OBJECTIVES } = require('../src/calibration/schemas');
 const {
@@ -512,8 +514,23 @@ if (!program.commands.some((cmd) => cmd.name() === 'help')) {
 
 // Ollama installation helper
 function getOllamaInstallInstructions() {
-    const platform = os.platform();
+    const rawPlatform = os.platform();
+    const platform = normalizePlatform(rawPlatform);
     const arch = os.arch();
+
+    if (isTermuxEnvironment(rawPlatform, process.env)) {
+        return {
+            name: `Termux (Android${arch ? ` ${arch}` : ''})`,
+            downloadUrl: 'https://github.com/termux/termux-packages',
+            instructions: [
+                '1. Update Termux packages: pkg update',
+                '2. Install Ollama from the Termux repository: pkg install ollama',
+                '3. Start Ollama in the current shell: ollama serve',
+                '4. In a new Termux session, test with: ollama run llama3.2:1b'
+            ],
+            alternativeInstall: 'pkg install ollama'
+        };
+    }
     
     const instructions = {
         'darwin': {
@@ -545,8 +562,8 @@ function getOllamaInstallInstructions() {
                 '1. Review official installation options:',
                 '   https://github.com/ollama/ollama/blob/main/docs/linux.md',
                 '2. Prefer a package manager (apt/dnf/pacman) when available',
-                '3. Start service after install:',
-                '   sudo systemctl start ollama',
+                '3. Start Ollama after install:',
+                '   ollama serve',
                 '4. Test with: ollama run llama2:7b'
             ],
             alternativeInstall: 'Manual install: https://github.com/ollama/ollama/blob/main/docs/linux.md'
@@ -855,6 +872,13 @@ function calculateModelCompatibilityScore(model, hardware) {
     return Math.max(0, Math.min(100, Math.round(score)));
 }
 
+function formatGpuInventoryList(models = []) {
+    if (!Array.isArray(models) || models.length === 0) return 'None';
+    return models
+        .map(({ name, count }) => (count > 1 ? `${count}x ${name}` : name))
+        .join(' + ');
+}
+
 // Helper function to get hardware tier for display
 function getHardwareTierForDisplay(hardware) {
     const ram = hardware.memory.total;
@@ -862,9 +886,15 @@ function getHardwareTierForDisplay(hardware) {
     const gpuModel = hardware.gpu?.model || '';
     const vramGB = hardware.gpu?.vram || 0;
     
-    // Check if it's integrated GPU (should cap tier)
-    const isIntegratedGPU = /iris.*xe|iris.*graphics|uhd.*graphics|vega.*integrated|radeon.*graphics|intel.*integrated|integrated/i.test(gpuModel);
-    const hasDedicatedGPU = vramGB > 0 && !isIntegratedGPU;
+    const integratedGpuInventory = Array.isArray(hardware.summary?.integratedGpuModels)
+        ? hardware.summary.integratedGpuModels.map(({ name }) => name).join(' ')
+        : '';
+    const isIntegratedGPU = typeof hardware.summary?.hasIntegratedGPU === 'boolean'
+        ? hardware.summary.hasIntegratedGPU
+        : /iris.*xe|iris.*graphics|uhd.*graphics|vega.*integrated|radeon.*graphics|intel.*integrated|integrated/i.test(`${gpuModel} ${integratedGpuInventory}`);
+    const hasDedicatedGPU = typeof hardware.summary?.hasDedicatedGPU === 'boolean'
+        ? hardware.summary.hasDedicatedGPU
+        : (vramGB > 0 && !isIntegratedGPU);
     const isAppleSilicon = process.platform === 'darwin' && (gpuModel.toLowerCase().includes('apple') || gpuModel.toLowerCase().includes('m1') || gpuModel.toLowerCase().includes('m2') || gpuModel.toLowerCase().includes('m3') || gpuModel.toLowerCase().includes('m4'));
     
     // Base tier calculation
@@ -931,6 +961,8 @@ function displaySystemInfo(hardware, analysis) {
     const cpuColor = hardware.cpu.cores >= 8 ? chalk.green : hardware.cpu.cores >= 4 ? chalk.yellow : chalk.red;
     const ramColor = hardware.memory.total >= 32 ? chalk.green : hardware.memory.total >= 16 ? chalk.yellow : chalk.red;
     const gpuColor = hardware.gpu.dedicated ? chalk.green : chalk.hex('#FFA500');
+    const integratedList = formatGpuInventoryList(hardware.gpu.integratedGpuModels || hardware.summary?.integratedGpuModels);
+    const dedicatedList = formatGpuInventoryList(hardware.gpu.dedicatedGpuModels || hardware.summary?.dedicatedGpuModels);
 
     const lines = [
         `${chalk.cyan('CPU:')} ${cpuColor(hardware.cpu.brand)} ${chalk.gray(`(${hardware.cpu.cores} cores, ${hardware.cpu.speed}GHz)`)}`,
@@ -938,6 +970,8 @@ function displaySystemInfo(hardware, analysis) {
         `${chalk.cyan('RAM:')} ${ramColor(hardware.memory.total + 'GB')}`,
         `${chalk.cyan('GPU:')} ${gpuColor(hardware.gpu.model || 'Not detected')}`,
         `${chalk.cyan('VRAM:')} ${hardware.gpu.vram === 0 && hardware.gpu.model && hardware.gpu.model.toLowerCase().includes('apple') ? 'Unified Memory' : `${hardware.gpu.vram || 'N/A'}GB`}${hardware.gpu.dedicated ? chalk.green(' (Dedicated)') : chalk.hex('#FFA500')(' (Integrated)')}`,
+        `${chalk.cyan('Dedicated GPUs:')} ${chalk.green(dedicatedList)}`,
+        `${chalk.cyan('Integrated GPUs:')} ${chalk.hex('#FFA500')(integratedList)}`,
     ];
 
     const tier = analysis.summary.hardwareTier?.replace('_', ' ').toUpperCase() || 'UNKNOWN';
@@ -1203,7 +1237,7 @@ function displayLegacyRecommendations(recommendations) {
     console.log(chalk.cyan('╰'));
 }
 
-function displayIntelligentRecommendations(intelligentData) {
+function displayIntelligentRecommendations(intelligentData, hardware = null) {
     if (!intelligentData || !intelligentData.summary) return;
 
     const { summary, recommendations } = intelligentData;
@@ -1220,10 +1254,12 @@ function displayIntelligentRecommendations(intelligentData) {
     // Mostrar mejor modelo general
     if (summary.best_overall) {
         const best = summary.best_overall;
+        const bestFineTuning = evaluateFineTuningSupport(best, hardware || {});
         console.log(chalk.red('│') + ` ${chalk.bold.yellow('BEST OVERALL:')} ${chalk.green.bold(best.name)}`);
         console.log(chalk.red('│') + `    Command: ${chalk.cyan.bold(best.command)}`);
         console.log(chalk.red('│') + `    Score: ${chalk.yellow.bold(best.score)}/100 | Category: ${chalk.magenta(best.category)}`);
         console.log(chalk.red('│') + `    Quantization: ${chalk.white.bold(best.quantization || 'Q4_K_M')}`);
+        console.log(chalk.red('│') + `    Fine-tuning: ${chalk.blue.bold(bestFineTuning.shortLabel)}`);
         console.log(chalk.red('│'));
     }
 
@@ -1242,11 +1278,13 @@ function displayIntelligentRecommendations(intelligentData) {
         const icon = categories[category] || 'Other';
         const categoryName = category.charAt(0).toUpperCase() + category.slice(1);
         const scoreColor = getScoreColor(model.score);
+        const fineTuningSupport = evaluateFineTuningSupport(model, hardware || {});
         
         console.log(chalk.red('│') + ` ${chalk.bold.white(categoryName)} (${icon}):`);
         console.log(chalk.red('│') + `    ${chalk.green(model.name)} (${model.size})`);
         console.log(chalk.red('│') + `    Score: ${scoreColor.bold(model.score)}/100 | Pulls: ${chalk.gray(model.pulls?.toLocaleString() || 'N/A')}`);
         console.log(chalk.red('│') + `    Quantization: ${chalk.white.bold(model.quantization || 'Q4_K_M')}`);
+        console.log(chalk.red('│') + `    Fine-tuning: ${chalk.blue.bold(fineTuningSupport.shortLabel)}`);
         console.log(chalk.red('│') + `    Command: ${chalk.cyan.bold(model.command)}`);
         console.log(chalk.red('│'));
     });
@@ -2079,6 +2117,8 @@ async function displayModelRecommendations(analysis, hardware, useCase = 'genera
             const realSize = getRealSizeFromOllamaCache(model) || estimateModelSize(model);
             console.log(`Size: ${chalk.white(realSize)}`);
             console.log(`Compatibility Score: ${chalk.green.bold(model.adjustedScore || model.score || 'N/A')}/100`);
+            const fineTuningSupport = evaluateFineTuningSupport(model, hardware);
+            console.log(`Fine-tuning: ${chalk.blue.bold(fineTuningSupport.shortLabel)}`);
             
             if (index === 0) {
                 console.log(`Reason: ${chalk.gray(reason)}`);
@@ -3628,7 +3668,7 @@ Calibrated routing examples:
             displaySystemInfo(hardware, { summary: { hardwareTier: intelligentRecommendations.summary.hardware_tier } });
             
             // Mostrar recomendaciones
-            displayIntelligentRecommendations(intelligentRecommendations);
+            displayIntelligentRecommendations(intelligentRecommendations, hardware);
             displayCalibratedRoutingDecision('recommend', calibratedPolicy, routeDecision, routingPreference.warnings);
 
             if (policyConfig && policyEvaluation && policyEnforcement) {
@@ -5019,6 +5059,11 @@ program
             console.log(`  Tier: ${chalk.cyan(detector.getHardwareTier().replace('_', ' ').toUpperCase())}`);
             console.log(`  Max model size: ${chalk.green(detector.getMaxModelSize() + 'GB')}`);
             console.log(`  Best backend: ${chalk.cyan(hardware.summary.bestBackend)}`);
+            console.log(`  Dedicated GPUs: ${chalk.green(formatGpuInventoryList(hardware.summary.dedicatedGpuModels))}`);
+            console.log(`  Integrated GPUs: ${chalk.hex('#FFA500')(formatGpuInventoryList(hardware.summary.integratedGpuModels))}`);
+            if (hardware.summary.hasIntegratedGPU && hardware.summary.bestBackend === 'cpu') {
+                console.log(`  Assist path: ${chalk.yellow('Integrated/shared-memory GPU detected, runtime remains CPU')}`);
+            }
 
             // CPU
             if (hardware.cpu) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-checker",
-  "version": "3.5.3",
+  "version": "3.5.6",
   "description": "Intelligent CLI tool with AI-powered model selection that analyzes your hardware and recommends optimal LLM models for your system",
   "bin": {
     "llm-checker": "bin/cli.js",
@@ -107,6 +107,7 @@
     "npm": ">=8.0.0"
   },
   "os": [
+    "android",
     "darwin",
     "linux",
     "win32"

package/src/ai/multi-objective-selector.js

@@ -9,6 +9,7 @@
  */
 
 const { MULTI_OBJECTIVE_WEIGHTS } = require('../models/scoring-config');
+const { normalizePlatform } = require('../utils/platform');
 
 class MultiObjectiveSelector {
     constructor() {
@@ -346,7 +347,14 @@ class MultiObjectiveSelector {
         const unified = isAppleSilicon;
         
         // Detect PC platform (Windows/Linux) to match main algorithm
-        const isPC = !isAppleSilicon && (process.platform === 'win32' || process.platform === 'linux');
+        const integratedGpuInventory = Array.isArray(hardware.summary?.integratedGpuModels)
+            ? hardware.summary.integratedGpuModels.map(({ name }) => name).join(' ')
+            : '';
+        const hasIntegratedGPU = typeof hardware.summary?.hasIntegratedGPU === 'boolean'
+            ? hardware.summary.hasIntegratedGPU
+            : /iris xe|uhd.*graphics|vega.*integrated|radeon.*graphics/i.test(`${gpuModel} ${integratedGpuInventory}`);
+        const platform = normalizePlatform(hardware?.os?.platform || process.platform);
+        const isPC = !isAppleSilicon && (platform === 'win32' || platform === 'linux');
         
         // 1) Effective memory for model weights (45%) - Apple Silicon & PC optimized
         let effMem;
@@ -446,7 +454,7 @@ class MultiObjectiveSelector {
             tier = bumpTier(tier, +1);  // High-end GPU boost
         } else if (!vramGB && !unified) {
             tier = bumpTier(tier, -1);  // CPU-only penalty (moderate)
-        } else if (/iris xe|uhd.*graphics|vega.*integrated|radeon.*graphics/i.test(gpuModel)) {
+        } else if (hasIntegratedGPU) {
             tier = bumpTier(tier, -1);  // iGPU penalty
         } else if (vramGB > 0 && vramGB < 6) {
             tier = bumpTier(tier, -1);  // Low VRAM penalty
@@ -658,7 +666,10 @@ class MultiObjectiveSelector {
         const cpuModel = hardware.cpu?.brand || hardware.cpu?.model || '';
         const gpuModel = hardware.gpu?.model || '';
         const cpu = cpuModel.toLowerCase();
-        const gpu = gpuModel.toLowerCase();
+        const integratedGpuInventory = Array.isArray(hardware.summary?.integratedGpuModels)
+            ? hardware.summary.integratedGpuModels.map(({ name }) => name).join(' ')
+            : '';
+        const gpu = `${gpuModel} ${integratedGpuInventory}`.toLowerCase();
         const cores = hardware.cpu?.physicalCores || hardware.cpu?.cores || 1;
         
         let specs = {
@@ -738,13 +749,16 @@ class MultiObjectiveSelector {
         const cores = hardware.cpu?.physicalCores || hardware.cpu?.cores || 1;
         const baseSpeed = hardware.cpu?.speed || 2.0;
         const vramGB = hardware.gpu?.vram || 0;
+        const hasIntegratedGPU = typeof hardware.summary?.hasIntegratedGPU === 'boolean'
+            ? hardware.summary.hasIntegratedGPU
+            : false;
         
         // Use improved CPU estimation function for more realistic and varying speeds
         const hasAVX512 = cpuModel.toLowerCase().includes('intel') && 
                          (cpuModel.includes('13th') || cpuModel.includes('14th') || cpuModel.includes('12th'));
         
         // GPU-based calculation (dedicated GPU only)
-        if (vramGB > 0 && !gpuModel.toLowerCase().includes('iris') && !gpuModel.toLowerCase().includes('integrated')) {
+        if (vramGB > 0 && !hasIntegratedGPU) {
             let gpuTPS = 20; // Conservative GPU baseline
             if (gpuModel.toLowerCase().includes('gb10') ||
                 gpuModel.toLowerCase().includes('grace blackwell') ||
@@ -780,7 +794,7 @@ class MultiObjectiveSelector {
                 threads: cores,
                 paramsB: params,
                 avx512: hasAVX512,
-                isIrisXe: gpuModel.toLowerCase().includes('iris xe')
+                isIrisXe: hasIntegratedGPU && gpuModel.toLowerCase().includes('iris xe')
             });
         }
     }

package/src/hardware/backends/cpu-detector.js

@@ -7,6 +7,7 @@
 const { execSync } = require('child_process');
 const os = require('os');
 const fs = require('fs');
+const { normalizePlatform } = require('../../utils/platform');
 
 class CPUDetector {
     constructor() {
@@ -87,10 +88,12 @@ class CPUDetector {
      * Get physical core count
      */
     getPhysicalCores() {
+        const platform = normalizePlatform();
+
         try {
-            if (process.platform === 'darwin') {
+            if (platform === 'darwin') {
                 return parseInt(execSync('sysctl -n hw.physicalcpu', { encoding: 'utf8', timeout: 5000 }).trim());
-            } else if (process.platform === 'linux') {
+            } else if (platform === 'linux') {
                 const cpuInfo = fs.readFileSync('/proc/cpuinfo', 'utf8');
                 const coreIds = new Set();
                 const matches = cpuInfo.matchAll(/core id\s*:\s*(\d+)/g);
@@ -98,7 +101,7 @@ class CPUDetector {
                     coreIds.add(match[1]);
                 }
                 return coreIds.size || os.cpus().length;
-            } else if (process.platform === 'win32') {
+            } else if (platform === 'win32') {
                 const physicalCores = this.getWindowsPhysicalCoreCount();
                 return physicalCores || os.cpus().length;
             }
@@ -112,18 +115,20 @@ class CPUDetector {
      * Get maximum CPU frequency
      */
     getMaxFrequency() {
+        const platform = normalizePlatform();
+
         try {
-            if (process.platform === 'darwin') {
+            if (platform === 'darwin') {
                 // macOS doesn't expose max frequency easily
                 const cpus = os.cpus();
                 return cpus.length > 0 ? cpus[0].speed : 0;
-            } else if (process.platform === 'linux') {
+            } else if (platform === 'linux') {
                 const maxFreq = fs.readFileSync(
                     '/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq',
                     'utf8'
                 );
                 return Math.round(parseInt(maxFreq) / 1000);  // kHz to MHz
-            } else if (process.platform === 'win32') {
+            } else if (platform === 'win32') {
                 const maxClock = this.getWindowsMaxClockSpeed();
                 return maxClock || (os.cpus()[0]?.speed || 0);
             }
@@ -206,13 +211,15 @@ class CPUDetector {
             l3: 0
         };
 
+        const platform = normalizePlatform();
+
         try {
-            if (process.platform === 'darwin') {
+            if (platform === 'darwin') {
                 cache.l1d = parseInt(execSync('sysctl -n hw.l1dcachesize', { encoding: 'utf8', timeout: 5000 })) / 1024 || 0;
                 cache.l1i = parseInt(execSync('sysctl -n hw.l1icachesize', { encoding: 'utf8', timeout: 5000 })) / 1024 || 0;
                 cache.l2 = parseInt(execSync('sysctl -n hw.l2cachesize', { encoding: 'utf8', timeout: 5000 })) / 1024 / 1024 || 0;
                 cache.l3 = parseInt(execSync('sysctl -n hw.l3cachesize', { encoding: 'utf8', timeout: 5000 })) / 1024 / 1024 || 0;
-            } else if (process.platform === 'linux') {
+            } else if (platform === 'linux') {
                 // Parse from /sys/devices/system/cpu/cpu0/cache/
                 const cachePath = '/sys/devices/system/cpu/cpu0/cache';
                 if (fs.existsSync(cachePath)) {
@@ -268,8 +275,10 @@ class CPUDetector {
             bestSimd: 'none'
         };
 
+        const platform = normalizePlatform();
+
         try {
-            if (process.platform === 'darwin') {
+            if (platform === 'darwin') {
                 // For Apple Silicon (ARM64), use ARM features
                 if (process.arch === 'arm64') {
                     caps.neon = true;  // All Apple Silicon has NEON
@@ -308,7 +317,7 @@ class CPUDetector {
                     }
                 }
 
-            } else if (process.platform === 'linux') {
+            } else if (platform === 'linux') {
                 // Linux - check /proc/cpuinfo
                 const cpuInfo = fs.readFileSync('/proc/cpuinfo', 'utf8').toLowerCase();
                 const flags = cpuInfo.match(/flags\s*:\s*(.+)/)?.[1] || '';
@@ -334,7 +343,7 @@ class CPUDetector {
                     caps.dotprod = flags.includes('asimddp');
                 }
 
-            } else if (process.platform === 'win32') {
+            } else if (platform === 'win32') {
                 // Windows - use WMIC or assume based on CPU model
                 const cpuName = os.cpus()[0]?.model?.toLowerCase() || '';
 

package/src/hardware/backends/rocm-detector.js

@@ -248,13 +248,20 @@ class ROCmDetector {
                 timeout: 10000
             });
 
-            // Parse memory info
-            const memMatches = memInfo.matchAll(/GPU\[(\d+)\].*?Total.*?:\s*(\d+)/g);
+            // Parse memory info. Newer rocm-smi reports bytes "(B)" while some
+            // systems expose MiB; normalize to GB safely.
             const gpuMemory = {};
-            for (const match of memMatches) {
-                const idx = parseInt(match[1]);
-                const memMB = parseInt(match[2]);
-                gpuMemory[idx] = Math.round(memMB / 1024);  // Convert to GB
+            const memLines = String(memInfo || '').split('\n');
+            for (const line of memLines) {
+                const lineMatch = line.match(/GPU\[(\d+)\].*?Total.*?Memory\s*(?:\(([^)]+)\))?\s*:\s*(\d+)/i);
+                if (!lineMatch) continue;
+
+                const idx = parseInt(lineMatch[1], 10);
+                const unitHint = lineMatch[2] || '';
+                const rawValue = parseInt(lineMatch[3], 10);
+
+                if (!Number.isFinite(rawValue) || rawValue <= 0) continue;
+                gpuMemory[idx] = this.normalizeRocmMemoryToGB(rawValue, unitHint);
             }
 
             // Get temperature and utilization
@@ -312,6 +319,45 @@ class ROCmDetector {
         }
     }
 
+    /**
+     * Normalize rocm-smi memory values to GB.
+     * rocm-smi may report bytes "(B)" or MiB depending on version/system.
+     */
+    normalizeRocmMemoryToGB(value, unitHint = '') {
+        const numericValue = Number(value);
+        if (!Number.isFinite(numericValue) || numericValue <= 0) {
+            return 0;
+        }
+
+        const unit = String(unitHint || '').toLowerCase();
+
+        if (unit.includes('gib') || unit.includes('gb')) {
+            return Math.round(numericValue);
+        }
+
+        if (unit.includes('mib') || unit.includes('mb')) {
+            return Math.round(numericValue / 1024);
+        }
+
+        if (unit.includes('kib') || unit.includes('kb')) {
+            return Math.round(numericValue / (1024 * 1024));
+        }
+
+        if (unit === 'b' || unit === 'bytes') {
+            return Math.round(numericValue / (1024 ** 3));
+        }
+
+        // Unit was not provided. Use value magnitude heuristics.
+        if (numericValue >= 1024 ** 3) {
+            return Math.round(numericValue / (1024 ** 3));
+        }
+        if (numericValue >= 1024) {
+            return Math.round(numericValue / 1024);
+        }
+
+        return Math.round(numericValue);
+    }
+
     /**
      * Detect GPUs via rocminfo
      */

package/src/hardware/detector.js

@@ -1,5 +1,6 @@
 const si = require('systeminformation');
 const UnifiedDetector = require('./unified-detector');
+const { normalizePlatform } = require('../utils/platform');
 
 class HardwareDetector {
     constructor() {
@@ -255,33 +256,75 @@ class HardwareDetector {
             }
 
             const primaryType = unified.primary.type || 'cpu';
-            if (primaryType === 'cpu') {
-                return;
-            }
-
             const summary = unified.summary;
-            const backendInfo = unified.backends?.[primaryType]?.info || {};
-            const backendGPUs = Array.isArray(backendInfo.gpus) ? backendInfo.gpus : [];
-            const gpuCount = summary.gpuCount || backendGPUs.length || systemInfo.gpu.gpuCount || 1;
-
-            const totalVRAM = typeof summary.totalVRAM === 'number' ? summary.totalVRAM : systemInfo.gpu.vram;
-            const perGPUVRAM = backendGPUs[0]?.memory?.total
-                || (gpuCount > 0 && totalVRAM > 0 ? Math.round(totalVRAM / gpuCount) : 0);
+            const hasFallbackDedicatedGpu = Boolean(
+                primaryType === 'cpu' &&
+                unified.systemGpu?.available &&
+                Array.isArray(unified.systemGpu.gpus) &&
+                unified.systemGpu.gpus.some((gpu) => gpu.type === 'dedicated')
+            );
+            const backendInfo = hasFallbackDedicatedGpu
+                ? unified.systemGpu
+                : (unified.backends?.[primaryType]?.info || {});
 
-            const modelFromUnified = summary.gpuInventory || summary.gpuModel || systemInfo.gpu.model;
+            const backendGPUs = Array.isArray(backendInfo.gpus) ? backendInfo.gpus : [];
+            const dedicatedBackendGPUs = backendGPUs.filter((gpu) => gpu?.type !== 'integrated');
+            const dedicatedInventoryModels = Array.isArray(summary.dedicatedGpuModels) ? summary.dedicatedGpuModels : [];
+            const integratedInventoryModels = Array.isArray(summary.integratedGpuModels) ? summary.integratedGpuModels : [];
+            const hasDedicatedGPU = Boolean(
+                summary.hasDedicatedGPU ||
+                dedicatedInventoryModels.length > 0 ||
+                dedicatedBackendGPUs.length > 0
+            );
+            const hasIntegratedGPU = Boolean(
+                summary.hasIntegratedGPU ||
+                integratedInventoryModels.length > 0 ||
+                backendGPUs.some((gpu) => gpu?.type === 'integrated')
+            );
+            const primaryDedicatedModel = dedicatedInventoryModels[0]?.name || dedicatedBackendGPUs[0]?.name || null;
+            const primaryIntegratedModel = integratedInventoryModels[0]?.name || null;
+
+            const gpuCount = summary.gpuCount ||
+                dedicatedBackendGPUs.length ||
+                backendGPUs.length ||
+                systemInfo.gpu.gpuCount ||
+                1;
+
+            const totalVRAMFromUnified = typeof summary.totalVRAM === 'number' ? summary.totalVRAM : 0;
+            const totalVRAMFromFallback = dedicatedBackendGPUs.reduce((sum, gpu) => {
+                const amount = Number(gpu?.memory?.total || gpu?.memoryTotal || 0);
+                return sum + (Number.isFinite(amount) ? amount : 0);
+            }, 0);
+            const totalVRAM = totalVRAMFromUnified || totalVRAMFromFallback || systemInfo.gpu.vram;
+            const perGPUVRAM = dedicatedBackendGPUs[0]?.memory?.total ||
+                (hasDedicatedGPU && gpuCount > 0 && totalVRAM > 0 ? Math.round(totalVRAM / Math.max(1, summary.dedicatedGpuCount || gpuCount)) : 0);
+
+            const fallbackModel = primaryDedicatedModel || primaryIntegratedModel || backendGPUs[0]?.name || null;
+            const modelFromUnified = summary.gpuModel || fallbackModel || systemInfo.gpu.model;
             const vendor = this.inferVendorFromGPUModel(modelFromUnified, systemInfo.gpu.vendor);
+            const isAppleUnified = primaryType === 'metal';
+
+            systemInfo.summary = {
+                ...summary
+            };
 
             systemInfo.gpu = {
                 ...systemInfo.gpu,
                 model: modelFromUnified,
                 vendor,
-                vram: totalVRAM || systemInfo.gpu.vram,
-                vramPerGPU: perGPUVRAM || systemInfo.gpu.vramPerGPU || 0,
-                dedicated: primaryType !== 'metal',
-                gpuCount,
+                vram: isAppleUnified ? systemInfo.gpu.vram : (hasDedicatedGPU ? (totalVRAM || systemInfo.gpu.vram) : 0),
+                vramPerGPU: isAppleUnified ? (systemInfo.gpu.vramPerGPU || 0) : (perGPUVRAM || systemInfo.gpu.vramPerGPU || 0),
+                dedicated: hasDedicatedGPU,
+                gpuCount: summary.gpuCount || gpuCount,
                 isMultiGPU: Boolean(summary.isMultiGPU || gpuCount > 1),
                 gpuInventory: summary.gpuInventory || null,
-                backend: primaryType,
+                hasIntegratedGPU,
+                hasDedicatedGPU,
+                integratedGpuCount: summary.integratedGpuCount || 0,
+                dedicatedGpuCount: summary.dedicatedGpuCount || 0,
+                integratedGpuModels: integratedInventoryModels,
+                dedicatedGpuModels: dedicatedInventoryModels,
+                backend: hasFallbackDedicatedGpu ? 'generic' : primaryType,
                 driverVersion: backendInfo.driver || systemInfo.gpu.driverVersion
             };
         } catch (error) {
@@ -301,8 +344,11 @@ class HardwareDetector {
     }
 
     processOSInfo(osInfo) {
+        const rawPlatform = osInfo.platform || process.platform;
+
         return {
-            platform: osInfo.platform || process.platform,
+            platform: normalizePlatform(rawPlatform),
+            platformRaw: rawPlatform,
             distro: osInfo.distro || 'Unknown',
             release: osInfo.release || 'Unknown',
             codename: osInfo.codename || 'Unknown',