llm-checker 3.5.4 → 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

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,
@@ -513,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': {
@@ -546,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'
@@ -856,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;
@@ -863,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
@@ -932,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)`)}`,
@@ -939,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';
@@ -5026,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.4",
+  "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/detector.js

@@ -1,5 +1,6 @@
 const si = require('systeminformation');
 const UnifiedDetector = require('./unified-detector');
+const { normalizePlatform } = require('../utils/platform');
 
 class HardwareDetector {
     constructor() {
@@ -255,24 +256,33 @@ class HardwareDetector {
             }
 
             const primaryType = unified.primary.type || 'cpu';
+            const summary = unified.summary;
             const hasFallbackDedicatedGpu = Boolean(
                 primaryType === 'cpu' &&
                 unified.systemGpu?.available &&
                 Array.isArray(unified.systemGpu.gpus) &&
                 unified.systemGpu.gpus.some((gpu) => gpu.type === 'dedicated')
             );
-
-            if (primaryType === 'cpu' && !hasFallbackDedicatedGpu) {
-                return;
-            }
-
-            const summary = unified.summary;
             const backendInfo = hasFallbackDedicatedGpu
                 ? unified.systemGpu
                 : (unified.backends?.[primaryType]?.info || {});
 
             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 ||
@@ -287,23 +297,33 @@ class HardwareDetector {
             }, 0);
             const totalVRAM = totalVRAMFromUnified || totalVRAMFromFallback || systemInfo.gpu.vram;
             const perGPUVRAM = dedicatedBackendGPUs[0]?.memory?.total ||
-                backendGPUs[0]?.memory?.total ||
-                (gpuCount > 0 && totalVRAM > 0 ? Math.round(totalVRAM / gpuCount) : 0);
+                (hasDedicatedGPU && gpuCount > 0 && totalVRAM > 0 ? Math.round(totalVRAM / Math.max(1, summary.dedicatedGpuCount || gpuCount)) : 0);
 
-            const fallbackModel = dedicatedBackendGPUs[0]?.name || backendGPUs[0]?.name || null;
-            const modelFromUnified = summary.gpuInventory || summary.gpuModel || fallbackModel || systemInfo.gpu.model;
+            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: hasFallbackDedicatedGpu ? true : 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,
+                hasIntegratedGPU,
+                hasDedicatedGPU,
+                integratedGpuCount: summary.integratedGpuCount || 0,
+                dedicatedGpuCount: summary.dedicatedGpuCount || 0,
+                integratedGpuModels: integratedInventoryModels,
+                dedicatedGpuModels: dedicatedInventoryModels,
                 backend: hasFallbackDedicatedGpu ? 'generic' : primaryType,
                 driverVersion: backendInfo.driver || systemInfo.gpu.driverVersion
             };
@@ -324,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',

package/src/hardware/unified-detector.js

@@ -11,6 +11,7 @@ const IntelDetector = require('./backends/intel-detector');
 const CPUDetector = require('./backends/cpu-detector');
 const si = require('systeminformation');
 const { execSync } = require('child_process');
+const { normalizePlatform } = require('../utils/platform');
 
 class UnifiedDetector {
     constructor() {
@@ -35,6 +36,8 @@ class UnifiedDetector {
             return this.cache;
         }
 
+        const platform = normalizePlatform();
+
         const result = {
             backends: {},
             primary: null,
@@ -64,7 +67,7 @@ class UnifiedDetector {
         }
 
         // Detect Apple Silicon (macOS ARM only)
-        if (process.platform === 'darwin' && process.arch === 'arm64') {
+        if (platform === 'darwin' && process.arch === 'arm64') {
             try {
                 const metalInfo = this.backends.metal.detect();
                 if (metalInfo) {
@@ -109,7 +112,7 @@ class UnifiedDetector {
         }
 
         // Detect Intel (Linux only for now)
-        if (process.platform === 'linux') {
+        if (platform === 'linux') {
             try {
                 if (this.backends.intel.checkAvailability()) {
                     const intelInfo = this.backends.intel.detect();
@@ -125,16 +128,9 @@ class UnifiedDetector {
             }
         }
 
-        // Fallback GPU inventory via systeminformation (Windows/Linux) when no
-        // accelerator backend is currently available (CUDA/ROCm/Metal/Intel).
-        const hasAcceleratedBackend = Boolean(
-            result.backends.cuda?.available ||
-            result.backends.rocm?.available ||
-            result.backends.metal?.available ||
-            result.backends.intel?.available
-        );
-
-        if (!hasAcceleratedBackend && (process.platform === 'win32' || process.platform === 'linux')) {
+        // Always collect a generic GPU inventory on Windows/Linux so integrated
+        // GPUs remain visible even when a dedicated backend is selected.
+        if (platform === 'win32' || platform === 'linux') {
             try {
                 const genericGpuInfo = await this.detectSystemGpuFallback();
                 if (genericGpuInfo?.available) {
@@ -229,14 +225,21 @@ class UnifiedDetector {
             gpuInventory: null,
             gpuModels: [],
             hasHeterogeneousGPU: false,
+            hasIntegratedGPU: false,
+            hasDedicatedGPU: false,
+            integratedGpuCount: 0,
+            dedicatedGpuCount: 0,
+            integratedGpuModels: [],
+            dedicatedGpuModels: [],
             cpuModel: result.cpu?.brand || 'Unknown',
             systemRAM: require('os').totalmem() / (1024 ** 3)
         };
 
         const primary = result.primary;
+        const inventorySource = this.getSummaryInventorySource(result);
 
         if (primary?.type === 'cuda' && primary.info) {
-            const inventory = this.summarizeGPUInventory(primary.info.gpus);
+            const inventory = this.summarizeGPUInventory(inventorySource);
             summary.totalVRAM = primary.info.totalVRAM;
             summary.gpuCount = primary.info.gpus.length;
             summary.isMultiGPU = primary.info.isMultiGPU;
@@ -247,7 +250,7 @@ class UnifiedDetector {
             summary.hasHeterogeneousGPU = inventory.isHeterogeneous;
         }
         else if (primary?.type === 'rocm' && primary.info) {
-            const inventory = this.summarizeGPUInventory(primary.info.gpus);
+            const inventory = this.summarizeGPUInventory(inventorySource);
             summary.totalVRAM = primary.info.totalVRAM;
             summary.gpuCount = primary.info.gpus.length;
             summary.isMultiGPU = primary.info.isMultiGPU;
@@ -259,15 +262,17 @@ class UnifiedDetector {
         }
         else if (primary?.type === 'metal' && primary.info) {
             // Apple Silicon uses unified memory
+            const inventory = this.summarizeGPUInventory(inventorySource);
             summary.totalVRAM = primary.info.memory.unified;
             summary.gpuCount = 1;
             summary.speedCoefficient = primary.info.speedCoefficient;
-            summary.gpuModel = primary.info.chip || 'Apple Silicon';
-            summary.gpuInventory = summary.gpuModel;
-            summary.gpuModels = [{ name: summary.gpuModel, count: 1 }];
+            summary.gpuModel = inventory.primaryModel || primary.info.chip || 'Apple Silicon';
+            summary.gpuInventory = inventory.displayName || summary.gpuModel;
+            summary.gpuModels = inventory.models;
+            summary.hasHeterogeneousGPU = inventory.isHeterogeneous;
         }
         else if (primary?.type === 'intel' && primary.info) {
-            const inventory = this.summarizeGPUInventory(primary.info.gpus);
+            const inventory = this.summarizeGPUInventory(inventorySource);
             summary.totalVRAM = primary.info.totalVRAM;
             summary.gpuCount = primary.info.gpus.filter(g => g.type === 'dedicated').length;
             summary.speedCoefficient = primary.info.speedCoefficient;
@@ -279,10 +284,10 @@ class UnifiedDetector {
         else if (result.cpu) {
             summary.speedCoefficient = result.cpu.speedCoefficient;
 
-            if (result.systemGpu?.available && Array.isArray(result.systemGpu.gpus) && result.systemGpu.gpus.length > 0) {
-                const inventory = this.summarizeGPUInventory(result.systemGpu.gpus);
+            if (inventorySource.length > 0) {
+                const inventory = this.summarizeGPUInventory(inventorySource);
                 summary.totalVRAM = result.systemGpu.totalVRAM || 0;
-                summary.gpuCount = result.systemGpu.gpus.length;
+                summary.gpuCount = inventory.dedicatedCount > 0 ? inventory.dedicatedCount : inventory.gpuCount;
                 summary.isMultiGPU = Boolean(result.systemGpu.isMultiGPU);
                 summary.gpuModel = inventory.primaryModel || null;
                 summary.gpuInventory = inventory.displayName || summary.gpuModel;
@@ -291,6 +296,24 @@ class UnifiedDetector {
             }
         }
 
+        const topology = this.summarizeGPUInventory(inventorySource);
+        summary.hasIntegratedGPU = topology.hasIntegratedGPU;
+        summary.hasDedicatedGPU = topology.hasDedicatedGPU;
+        summary.integratedGpuCount = topology.integratedCount;
+        summary.dedicatedGpuCount = topology.dedicatedCount;
+        summary.integratedGpuModels = topology.integratedModels;
+        summary.dedicatedGpuModels = topology.dedicatedModels;
+        if (!summary.gpuModel) {
+            summary.gpuModel = topology.primaryModel || null;
+        }
+        if (!summary.gpuInventory) {
+            summary.gpuInventory = topology.displayName || summary.gpuModel;
+        }
+        if (!summary.gpuModels.length) {
+            summary.gpuModels = topology.models;
+        }
+        summary.hasHeterogeneousGPU = summary.hasHeterogeneousGPU || topology.isHeterogeneous;
+
         // Effective memory for LLM loading
         // For GPU: use VRAM; for CPU/Metal: use system RAM
         if (summary.totalVRAM > 0 && ['cuda', 'rocm', 'intel'].includes(primary?.type)) {
@@ -304,26 +327,110 @@ class UnifiedDetector {
     }
 
     summarizeGPUInventory(gpus = []) {
+        const normalized = this.normalizeGpuInventory(gpus);
         const counts = new Map();
+        const integratedCounts = new Map();
+        const dedicatedCounts = new Map();
 
-        for (const gpu of gpus) {
+        for (const gpu of normalized) {
             const name = (gpu?.name || 'Unknown GPU').replace(/\s+/g, ' ').trim();
             counts.set(name, (counts.get(name) || 0) + 1);
+            if (gpu.type === 'integrated') {
+                integratedCounts.set(name, (integratedCounts.get(name) || 0) + 1);
+            } else {
+                dedicatedCounts.set(name, (dedicatedCounts.get(name) || 0) + 1);
+            }
         }
 
         const models = Array.from(counts.entries()).map(([name, count]) => ({ name, count }));
+        const integratedModels = Array.from(integratedCounts.entries()).map(([name, count]) => ({ name, count }));
+        const dedicatedModels = Array.from(dedicatedCounts.entries()).map(([name, count]) => ({ name, count }));
         const displayName = models
             .map(({ name, count }) => (count > 1 ? `${count}x ${name}` : name))
             .join(' + ');
 
         return {
-            primaryModel: models[0]?.name || null,
+            primaryModel: dedicatedModels[0]?.name || integratedModels[0]?.name || models[0]?.name || null,
             displayName: displayName || null,
             models,
+            integratedModels,
+            dedicatedModels,
+            integratedCount: normalized.filter((gpu) => gpu.type === 'integrated').length,
+            dedicatedCount: normalized.filter((gpu) => gpu.type === 'dedicated').length,
+            hasIntegratedGPU: normalized.some((gpu) => gpu.type === 'integrated'),
+            hasDedicatedGPU: normalized.some((gpu) => gpu.type === 'dedicated'),
+            gpuCount: normalized.length,
             isHeterogeneous: models.length > 1
         };
     }
 
+    getSummaryInventorySource(result) {
+        const primaryInventory = this.getPrimaryInventoryGpus(result.primary);
+        const systemInventory = Array.isArray(result.systemGpu?.gpus) ? result.systemGpu.gpus : [];
+        return this.mergeGpuInventories(primaryInventory, systemInventory);
+    }
+
+    getPrimaryInventoryGpus(primary) {
+        if (!primary?.info) return [];
+
+        if (Array.isArray(primary.info.gpus) && primary.info.gpus.length > 0) {
+            return primary.info.gpus;
+        }
+
+        if (primary.type === 'metal') {
+            return [{
+                name: primary.info.chip || 'Apple Silicon',
+                type: 'integrated',
+                memory: { total: primary.info.memory?.unified || 0 }
+            }];
+        }
+
+        return [];
+    }
+
+    normalizeGpuInventory(gpus = []) {
+        return gpus
+            .map((gpu) => {
+                const name = String(gpu?.name || gpu?.model || '').replace(/\s+/g, ' ').trim();
+                if (!name) return null;
+
+                let type = gpu?.type;
+                if (type !== 'integrated' && type !== 'dedicated') {
+                    type = this.isIntegratedGPUModel(name) ? 'integrated' : 'dedicated';
+                }
+
+                const totalMemory = Number(gpu?.memory?.total || gpu?.memoryTotal || gpu?.memory || 0);
+
+                return {
+                    name,
+                    type,
+                    memory: {
+                        total: Number.isFinite(totalMemory) ? totalMemory : 0
+                    }
+                };
+            })
+            .filter(Boolean);
+    }
+
+    mergeGpuInventories(...gpuLists) {
+        const normalizedLists = gpuLists.map((list) => this.normalizeGpuInventory(list));
+        const primaryIndex = normalizedLists.findIndex((list) => list.length > 0);
+        const merged = [];
+        const seen = new Set();
+
+        normalizedLists.forEach((list, listIndex) => {
+            for (const gpu of list) {
+                const key = `${this.getGpuMatchKey(gpu.name)}|${gpu.type}`;
+                if (!key) continue;
+                if (listIndex !== primaryIndex && seen.has(key)) continue;
+                merged.push(gpu);
+                seen.add(key);
+            }
+        });
+
+        return merged;
+    }
+
     async detectSystemGpuFallback() {
         const graphics = await si.graphics();
         const controllers = Array.isArray(graphics?.controllers) ? graphics.controllers : [];
@@ -364,7 +471,9 @@ class UnifiedDetector {
             })
             .filter(Boolean);
 
-        if (process.platform === 'linux') {
+        const platform = normalizePlatform();
+
+        if (platform === 'linux') {
             const lspciControllers = this.detectLinuxLspciGpus();
             const knownKeys = new Set(
                 normalized.map((gpu) => this.getGpuMatchKey(gpu.name)).filter(Boolean)
@@ -396,7 +505,7 @@ class UnifiedDetector {
 
         return {
             available: true,
-            source: process.platform === 'linux' ? 'systeminformation+lspci' : 'systeminformation',
+            source: normalized.some((gpu) => gpu.source === 'lspci') ? 'systeminformation+lspci' : 'systeminformation',
             gpus: normalized,
             totalVRAM,
             isMultiGPU: dedicated.length > 1,
@@ -457,7 +566,8 @@ class UnifiedDetector {
                 name,
                 vendor: isNvidia ? 'NVIDIA' : (isAMD ? 'AMD' : 'Intel'),
                 type: isIntegrated ? 'integrated' : 'dedicated',
-                memory: { total: vram }
+                memory: { total: vram },
+                source: 'lspci'
             });
         }
 
@@ -709,6 +819,10 @@ class UnifiedDetector {
             return `${gpuDesc} (${summary.totalVRAM}GB) + ${summary.cpuModel}`;
         }
         else {
+            if (summary.gpuModel && summary.hasIntegratedGPU && !summary.hasDedicatedGPU) {
+                const gpuDesc = summary.gpuInventory || summary.gpuModel;
+                return `${gpuDesc} (integrated/shared memory, CPU backend) + ${summary.cpuModel}`;
+            }
             if (summary.gpuModel && summary.gpuCount > 0) {
                 const gpuDesc = summary.gpuInventory || summary.gpuModel;
                 return `${gpuDesc} (${summary.totalVRAM}GB VRAM detected, CPU backend) + ${summary.cpuModel}`;

package/src/index.js

@@ -18,6 +18,7 @@ const {
     attachModelProvenance,
     attachProvenanceToCollection
 } = require('./provenance/model-provenance');
+const { normalizePlatform } = require('./utils/platform');
 
 class LLMChecker {
     constructor(options = {}) {
@@ -72,7 +73,7 @@ class LLMChecker {
             this.logger.info('Hardware detected', { hardware });
 
             // Detect platform and route to appropriate logic (use hardware OS for simulation support)
-            const detectedPlatform = hardware.os?.platform || process.platform;
+            const detectedPlatform = normalizePlatform(hardware.os?.platform || process.platform);
 
             // Report hardware detection progress before platform-specific analysis
             if (this.progress) {
@@ -1370,7 +1371,8 @@ class LLMChecker {
         const unified = isAppleSilicon;
         
         // Detect PC platform (Windows/Linux)
-        const isPC = !isAppleSilicon && (process.platform === 'win32' || process.platform === 'linux');
+        const normalizedPlatform = normalizePlatform(hardware.os?.platform || process.platform);
+        const isPC = !isAppleSilicon && (normalizedPlatform === 'win32' || normalizedPlatform === 'linux');
         const hasAVX512 = cpuModel.toLowerCase().includes('intel') && 
                          (cpuModel.includes('12th') || cpuModel.includes('13th') || cpuModel.includes('14th'));
         const hasAVX2 = cpuModel.toLowerCase().includes('intel') || 
@@ -1434,7 +1436,7 @@ class LLMChecker {
             compute = clamp(tflopsFP16 / 80);  // GPU: normalizado contra 80 TFLOPs (más realista)
             
             // Cap iGPU compute
-            if (/iris xe|uhd|vega.*integrated|radeon.*graphics/i.test(gpuModel)) {
+            if (Boolean(hardware.summary?.hasIntegratedGPU) || /iris xe|uhd|vega.*integrated|radeon.*graphics/i.test(gpuModel)) {
                 compute = Math.min(compute, 0.15);
             }
         } else {
@@ -1467,9 +1469,15 @@ class LLMChecker {
                   score >= 35 ? 'medium' :         // 35-54 for mid-range systems
                   score >= 20 ? 'low' : 'ultra_low'; // 20-34 for budget systems
         
-        // Detect if system has dedicated GPU (not integrated) - improved detection
-        const hasIntegratedGPU = /iris.*xe|iris.*graphics|uhd.*graphics|vega.*integrated|radeon.*graphics|intel.*integrated|integrated/i.test(gpuModel);
-        const hasDedicatedGPU = vramGB > 0 && !hasIntegratedGPU && !unified;
+        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|iris.*graphics|uhd.*graphics|vega.*integrated|radeon.*graphics|intel.*integrated|integrated/i.test(`${gpuModel} ${integratedGpuInventory}`);
+        const hasDedicatedGPU = typeof hardware.summary?.hasDedicatedGPU === 'boolean'
+            ? (!unified && hardware.summary.hasDedicatedGPU)
+            : (vramGB > 0 && !hasIntegratedGPU && !unified);
         
         // Debug logging for tier calculation
         if (process.env.DEBUG_TIER) {
@@ -1747,7 +1755,10 @@ class LLMChecker {
         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 = {

package/src/runtime/runtime-support.js

@@ -1,4 +1,5 @@
 const SUPPORTED_RUNTIMES = ['ollama', 'vllm', 'mlx'];
+const { normalizePlatform, isTermuxEnvironment } = require('../utils/platform');
 
 function normalizeRuntime(runtime = 'ollama') {
     const normalized = String(runtime || 'ollama').trim().toLowerCase();
@@ -114,7 +115,19 @@ function getRuntimeInstallCommand(runtime = 'ollama') {
         return 'pip install -U mlx-lm';
     }
 
-    return 'ollama --version || (brew install ollama)';
+    if (isTermuxEnvironment()) {
+        return 'pkg install ollama';
+    }
+
+    const platform = normalizePlatform();
+    if (platform === 'darwin') {
+        return 'brew install ollama';
+    }
+    if (platform === 'win32') {
+        return 'winget install Ollama.Ollama';
+    }
+
+    return 'curl -fsSL https://ollama.com/install.sh | sh';
 }
 
 function getRuntimePullCommand(model = {}, runtime = 'ollama') {

package/src/utils/formatter.js

@@ -22,6 +22,18 @@ class OutputFormatter {
             ? 'Unified Memory' 
             : `${hardware.gpu.vram || 'N/A'}GB`;
         lines.push(this.info('VRAM', `${vramDisplay}${hardware.gpu.dedicated ? ' (Dedicated)' : ' (Integrated)'}`));
+        if (Array.isArray(hardware.gpu.dedicatedGpuModels) && hardware.gpu.dedicatedGpuModels.length > 0) {
+            const dedicated = hardware.gpu.dedicatedGpuModels
+                .map(({ name, count }) => (count > 1 ? `${count}x ${name}` : name))
+                .join(' + ');
+            lines.push(this.info('Dedicated GPUs', dedicated));
+        }
+        if (Array.isArray(hardware.gpu.integratedGpuModels) && hardware.gpu.integratedGpuModels.length > 0) {
+            const integrated = hardware.gpu.integratedGpuModels
+                .map(({ name, count }) => (count > 1 ? `${count}x ${name}` : name))
+                .join(' + ');
+            lines.push(this.info('Integrated GPUs', integrated));
+        }
         lines.push(this.info('OS', `${hardware.os.distro} ${hardware.os.release} (${hardware.os.arch})`));
 
         return lines.join('\n');
@@ -312,4 +324,4 @@ class OutputFormatter {
     }
 }
 
-module.exports = OutputFormatter;
+module.exports = OutputFormatter;

package/src/utils/platform.js

@@ -0,0 +1,44 @@
+function normalizePlatform(platform = process.platform) {
+    const normalized = String(platform || process.platform).trim().toLowerCase();
+
+    if (normalized === 'android') {
+        return 'linux';
+    }
+
+    if (normalized === 'macos') {
+        return 'darwin';
+    }
+
+    return normalized;
+}
+
+function isLinuxPlatform(platform = process.platform) {
+    return normalizePlatform(platform) === 'linux';
+}
+
+function isWindowsPlatform(platform = process.platform) {
+    return normalizePlatform(platform) === 'win32';
+}
+
+function isDarwinPlatform(platform = process.platform) {
+    return normalizePlatform(platform) === 'darwin';
+}
+
+function isTermuxEnvironment(platform = process.platform, env = process.env) {
+    if (String(platform || process.platform).trim().toLowerCase() === 'android') {
+        return true;
+    }
+
+    const prefix = String(env?.PREFIX || '');
+    const termuxVersion = String(env?.TERMUX_VERSION || '');
+
+    return prefix.includes('com.termux') || termuxVersion.length > 0;
+}
+
+module.exports = {
+    normalizePlatform,
+    isLinuxPlatform,
+    isWindowsPlatform,
+    isDarwinPlatform,
+    isTermuxEnvironment
+};

package/src/utils/token-speed-estimator.js

@@ -31,6 +31,35 @@ function isIntegratedGPU(gpuModel = '') {
     return /iris.*xe|iris.*graphics|uhd.*graphics|vega.*integrated|radeon.*graphics|intel.*integrated|integrated/i.test(gpuModel);
 }
 
+function getIntegratedGpuNames(hardware = {}) {
+    if (!Array.isArray(hardware.summary?.integratedGpuModels)) return '';
+    return hardware.summary.integratedGpuModels
+        .map((model) => model?.name)
+        .filter(Boolean)
+        .join(' ');
+}
+
+function detectIntegratedGpu(hardware = {}, gpuModel = '') {
+    if (typeof hardware.summary?.hasIntegratedGPU === 'boolean') {
+        return hardware.summary.hasIntegratedGPU;
+    }
+    if (typeof hardware.gpu?.hasIntegratedGPU === 'boolean') {
+        return hardware.gpu.hasIntegratedGPU;
+    }
+    return isIntegratedGPU(`${gpuModel} ${getIntegratedGpuNames(hardware)}`.trim());
+}
+
+function detectDedicatedGpu(hardware = {}, integrated = false, appleSilicon = false, vramGB = 0) {
+    if (appleSilicon) return false;
+    if (typeof hardware.summary?.hasDedicatedGPU === 'boolean') {
+        return hardware.summary.hasDedicatedGPU && vramGB > 0;
+    }
+    if (typeof hardware.gpu?.hasDedicatedGPU === 'boolean') {
+        return hardware.gpu.hasDedicatedGPU && vramGB > 0;
+    }
+    return vramGB > 0 && !integrated;
+}
+
 function getAppleSiliconBaseline(cpuModel, gpuModel) {
     const signal = `${cpuModel} ${gpuModel}`.toLowerCase();
     const profiles = [
@@ -162,8 +191,8 @@ function estimateTokenSpeedFromHardware(hardware = {}, options = {}) {
     );
 
     const appleSilicon = detectAppleSilicon(architecture, cpuModel, gpuModel);
-    const integrated = isIntegratedGPU(gpuModel);
-    const dedicatedGPU = vramGB > 0 && !integrated && !appleSilicon;
+    const integrated = detectIntegratedGpu(hardware, gpuModel);
+    const dedicatedGPU = detectDedicatedGpu(hardware, integrated, appleSilicon, vramGB);
 
     let baselineTPS7B;
     let backend;