llm-checker 3.5.6 → 3.5.7

package/bin/mcp-server.mjs

@@ -187,7 +187,7 @@ const ALLOWED_CLI_COMMANDS = new Set([
 
 const server = new McpServer({
   name: "llm-checker",
-  version: "3.4.0",
+  version: "3.5.7",
 });
 
 // ============================================================================

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-checker",
-  "version": "3.5.6",
+  "version": "3.5.7",
   "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",

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

@@ -353,13 +353,16 @@ class MultiObjectiveSelector {
         const hasIntegratedGPU = typeof hardware.summary?.hasIntegratedGPU === 'boolean'
             ? hardware.summary.hasIntegratedGPU
             : /iris xe|uhd.*graphics|vega.*integrated|radeon.*graphics/i.test(`${gpuModel} ${integratedGpuInventory}`);
+        const hasDedicatedGPU = typeof hardware.summary?.hasDedicatedGPU === 'boolean'
+            ? hardware.summary.hasDedicatedGPU
+            : Boolean(hardware.gpu?.dedicated || (vramGB > 0 && !hasIntegratedGPU));
         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;
         
-        if (vramGB > 0 && !unified) {
+        if (hasDedicatedGPU && vramGB > 0 && !unified) {
             // Dedicated GPU path (Windows/Linux with discrete GPU)
             if (isPC) {
                 // PC-specific GPU memory calculation with offload support
@@ -454,9 +457,9 @@ class MultiObjectiveSelector {
             tier = bumpTier(tier, +1);  // High-end GPU boost
         } else if (!vramGB && !unified) {
             tier = bumpTier(tier, -1);  // CPU-only penalty (moderate)
-        } else if (hasIntegratedGPU) {
+        } else if (hasIntegratedGPU && !hasDedicatedGPU) {
             tier = bumpTier(tier, -1);  // iGPU penalty
-        } else if (vramGB > 0 && vramGB < 6) {
+        } else if (hasDedicatedGPU && vramGB > 0 && vramGB < 6) {
             tier = bumpTier(tier, -1);  // Low VRAM penalty
         }
         
@@ -752,13 +755,16 @@ class MultiObjectiveSelector {
         const hasIntegratedGPU = typeof hardware.summary?.hasIntegratedGPU === 'boolean'
             ? hardware.summary.hasIntegratedGPU
             : false;
+        const hasDedicatedGPU = typeof hardware.summary?.hasDedicatedGPU === 'boolean'
+            ? hardware.summary.hasDedicatedGPU
+            : Boolean(hardware.gpu?.dedicated || (vramGB > 0 && !hasIntegratedGPU));
         
         // 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 && !hasIntegratedGPU) {
+        if (hasDedicatedGPU && vramGB > 0) {
             let gpuTPS = 20; // Conservative GPU baseline
             if (gpuModel.toLowerCase().includes('gb10') ||
                 gpuModel.toLowerCase().includes('grace blackwell') ||

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

@@ -4,7 +4,7 @@
  * Focuses on AVX2, AVX512, AMX, and other SIMD extensions
  */
 
-const { execSync } = require('child_process');
+const childProcess = require('child_process');
 const os = require('os');
 const fs = require('fs');
 const { normalizePlatform } = require('../../utils/platform');
@@ -92,7 +92,7 @@ class CPUDetector {
 
         try {
             if (platform === 'darwin') {
-                return parseInt(execSync('sysctl -n hw.physicalcpu', { encoding: 'utf8', timeout: 5000 }).trim());
+                return parseInt(childProcess.execSync('sysctl -n hw.physicalcpu', { encoding: 'utf8', timeout: 5000 }).trim());
             } else if (platform === 'linux') {
                 const cpuInfo = fs.readFileSync('/proc/cpuinfo', 'utf8');
                 const coreIds = new Set();
@@ -142,7 +142,37 @@ class CPUDetector {
      * Execute shell command with consistent options.
      */
     runCommand(command) {
-        return execSync(command, { encoding: 'utf8', timeout: 5000 });
+        const baseOptions = {
+            encoding: 'utf8',
+            timeout: 5000
+        };
+
+        if (normalizePlatform() === 'win32') {
+            const result = childProcess.spawnSync(command, {
+                ...baseOptions,
+                shell: true,
+                stdio: ['ignore', 'pipe', 'pipe'],
+                windowsHide: true
+            });
+
+            if (result.error) {
+                throw result.error;
+            }
+
+            if (result.status !== 0) {
+                const stderr = String(result.stderr || '').trim();
+                const stdout = String(result.stdout || '').trim();
+                const error = new Error(stderr || stdout || `Command failed: ${command}`);
+                error.status = result.status;
+                error.stdout = result.stdout;
+                error.stderr = result.stderr;
+                throw error;
+            }
+
+            return result.stdout;
+        }
+
+        return childProcess.execSync(command, baseOptions);
     }
 
     /**
@@ -215,10 +245,10 @@ class CPUDetector {
 
         try {
             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;
+                cache.l1d = parseInt(childProcess.execSync('sysctl -n hw.l1dcachesize', { encoding: 'utf8', timeout: 5000 })) / 1024 || 0;
+                cache.l1i = parseInt(childProcess.execSync('sysctl -n hw.l1icachesize', { encoding: 'utf8', timeout: 5000 })) / 1024 || 0;
+                cache.l2 = parseInt(childProcess.execSync('sysctl -n hw.l2cachesize', { encoding: 'utf8', timeout: 5000 })) / 1024 / 1024 || 0;
+                cache.l3 = parseInt(childProcess.execSync('sysctl -n hw.l3cachesize', { encoding: 'utf8', timeout: 5000 })) / 1024 / 1024 || 0;
             } else if (platform === 'linux') {
                 // Parse from /sys/devices/system/cpu/cpu0/cache/
                 const cachePath = '/sys/devices/system/cpu/cpu0/cache';
@@ -288,12 +318,12 @@ class CPUDetector {
                 } else {
                     // Intel Mac - check via sysctl
                     try {
-                        const features = execSync('sysctl -n machdep.cpu.features', {
+                        const features = childProcess.execSync('sysctl -n machdep.cpu.features', {
                             encoding: 'utf8',
                             timeout: 5000
                         }).toLowerCase();
 
-                        const leafFeatures = execSync('sysctl -n machdep.cpu.leaf7_features', {
+                        const leafFeatures = childProcess.execSync('sysctl -n machdep.cpu.leaf7_features', {
                             encoding: 'utf8',
                             timeout: 5000
                         }).toLowerCase();

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

@@ -15,6 +15,10 @@ class CUDADetector {
         this.detectionMode = null;
     }
 
+    execCommand(command, options = {}) {
+        return execSync(command, options);
+    }
+
     /**
      * Check if CUDA is available
      */
@@ -43,7 +47,7 @@ class CUDADetector {
 
     hasNvidiaSMI() {
         try {
-            execSync('nvidia-smi --version', {
+            this.execCommand('nvidia-smi --version', {
                 encoding: 'utf8',
                 timeout: 5000,
                 stdio: ['pipe', 'pipe', 'pipe']
@@ -142,7 +146,7 @@ class CUDADetector {
         }
 
         try {
-            execSync('nvcc --version', {
+            this.execCommand('nvcc --version', {
                 encoding: 'utf8',
                 timeout: 5000,
                 stdio: ['pipe', 'pipe', 'pipe']
@@ -197,17 +201,18 @@ class CUDADetector {
 
         try {
             // Get driver and CUDA version
-            const versionInfo = execSync('nvidia-smi --query-gpu=driver_version --format=csv,noheader,nounits', {
+            const versionInfo = this.execCommand('nvidia-smi --query-gpu=driver_version --format=csv,noheader,nounits', {
                 encoding: 'utf8',
                 timeout: 5000
             }).trim().split('\n')[0];
             result.driver = versionInfo;
 
-            // Get CUDA version from nvidia-smi header
-            const header = execSync('nvidia-smi | head -n 3', {
+            // Parse the nvidia-smi banner in JS so Windows does not require shell-only tools like `head`.
+            const banner = this.execCommand('nvidia-smi', {
                 encoding: 'utf8',
                 timeout: 5000
             });
+            const header = banner.split('\n').slice(0, 3).join('\n');
             const cudaMatch = header.match(/CUDA Version:\s*([\d.]+)/);
             if (cudaMatch) {
                 result.cuda = cudaMatch[1];
@@ -237,7 +242,7 @@ class CUDADetector {
                 'clocks.max.sm'
             ].join(',');
 
-            const gpuData = execSync(
+            const gpuData = this.execCommand(
                 `nvidia-smi --query-gpu=${query} --format=csv,noheader,nounits`,
                 { encoding: 'utf8', timeout: 10000 }
             ).trim();
@@ -286,7 +291,7 @@ class CUDADetector {
         } catch (e) {
             // Fallback to simpler query
             try {
-                const simpleQuery = execSync(
+                const simpleQuery = this.execCommand(
                     'nvidia-smi --query-gpu=name,memory.total --format=csv,noheader,nounits',
                     { encoding: 'utf8', timeout: 5000 }
                 ).trim();
@@ -408,7 +413,7 @@ class CUDADetector {
         }
 
         try {
-            const nvccVersion = execSync('nvcc --version', {
+            const nvccVersion = this.execCommand('nvcc --version', {
                 encoding: 'utf8',
                 timeout: 5000,
                 stdio: ['pipe', 'pipe', 'pipe']

package/src/hardware/detector.js

@@ -41,7 +41,7 @@ class HardwareDetector {
             const systemInfo = {
                 cpu: this.processCPUInfo(cpu),
                 memory: this.processMemoryInfo(memory),
-                gpu: this.processGPUInfo(graphics),
+                gpu: this.processGPUInfo(graphics, memory),
                 system: this.processSystemInfo(system),
                 os: this.processOSInfo(osInfo),
                 timestamp: Date.now()
@@ -97,7 +97,48 @@ class HardwareDetector {
         };
     }
 
-    processGPUInfo(graphics) {
+    getSystemMemoryGB(memoryInfo) {
+        const totalBytes = Number(memoryInfo?.total || 0);
+        if (!Number.isFinite(totalBytes) || totalBytes <= 0) return 0;
+        return Math.max(1, Math.round(totalBytes / (1024 ** 3)));
+    }
+
+    estimateIntegratedSharedMemory(gpu, memoryInfo) {
+        const dedicatedAperture = this.normalizeVRAM(gpu?.vram || 0);
+        const explicitSharedCandidates = [
+            gpu?.memoryTotal,
+            gpu?.memory,
+            gpu?.sharedMemory,
+            gpu?.memoryShared,
+            gpu?.memory?.shared,
+            gpu?.memory?.total
+        ]
+            .map((value) => this.normalizeVRAM(value))
+            .filter((value) => value > dedicatedAperture);
+
+        if (explicitSharedCandidates.length > 0) {
+            return Math.max(...explicitSharedCandidates);
+        }
+
+        const totalSystemGB = this.getSystemMemoryGB(memoryInfo);
+        if (gpu?.vramDynamic || dedicatedAperture <= 2) {
+            return this.estimateSystemSharedMemory(totalSystemGB, dedicatedAperture);
+        }
+
+        return dedicatedAperture;
+    }
+
+    estimateSystemSharedMemory(totalSystemGB, fallbackGB = 0) {
+        const fallback = Math.max(0, Number(fallbackGB) || 0);
+        if (!Number.isFinite(totalSystemGB) || totalSystemGB <= 0) {
+            return fallback;
+        }
+
+        // Integrated GPUs typically expose roughly half of system RAM as a shared pool.
+        return Math.max(fallback, Math.min(Math.max(1, Math.round(totalSystemGB / 2)), 16));
+    }
+
+    processGPUInfo(graphics, memoryInfo = null) {
         const controllers = graphics.controllers || [];
         const displays = graphics.displays || [];
 
@@ -199,8 +240,14 @@ class HardwareDetector {
             enhancedModel = this.getGPUModelFromDeviceId(primaryGPU.deviceId) || enhancedModel;
         }
 
+        const primaryIsIntegrated = this.isIntegratedGPU(enhancedModel);
+        const normalizedPrimaryVRAM = this.normalizeVRAM(primaryGPU.vram || 0);
+        const estimatedSharedMemory = primaryIsIntegrated
+            ? this.estimateIntegratedSharedMemory(primaryGPU, memoryInfo)
+            : 0;
+
         // Enhanced VRAM detection using the new normalizeVRAM function
-        let vram = this.normalizeVRAM(primaryGPU.vram || 0);
+        let vram = primaryIsIntegrated ? estimatedSharedMemory : normalizedPrimaryVRAM;
         
         // If VRAM is still 0, try to estimate based on model or handle unified memory
         if (vram === 0 && primaryGPU.model) {
@@ -227,24 +274,41 @@ class HardwareDetector {
 
         // If we have multiple dedicated GPUs, use the combined VRAM
         const effectiveVRAM = gpuCount > 1 ? totalDedicatedVRAM : vram;
+        const sharedMemory = primaryIsIntegrated ? effectiveVRAM : 0;
+        const dedicatedMemory = primaryIsIntegrated ? normalizedPrimaryVRAM : effectiveVRAM;
+        const scoredGPU = {
+            ...primaryGPU,
+            model: enhancedModel,
+            vram: effectiveVRAM,
+            sharedMemory,
+            dedicatedMemory
+        };
 
         return {
             model: enhancedModel,
             vendor: primaryGPU.vendor || this.inferVendorFromGPUModel(enhancedModel, 'Unknown'),
             vram: effectiveVRAM,
             vramPerGPU: vram, // VRAM of primary GPU for reference
+            sharedMemory,
+            dedicatedMemory,
             vramDynamic: primaryGPU.vramDynamic || false,
-            dedicated: !this.isIntegratedGPU(enhancedModel),
+            dedicated: !primaryIsIntegrated,
             driverVersion: primaryGPU.driverVersion || 'Unknown',
             gpuCount: gpuCount > 0 ? gpuCount : (dedicatedGPUs.length > 0 ? dedicatedGPUs.length : 1),
             isMultiGPU: gpuCount > 1,
             all: normalizedControllers.map(gpu => ({
                 model: gpu.model,
-                vram: this.normalizeVRAM(gpu.vram || 0),
+                vram: this.isIntegratedGPU(gpu.model)
+                    ? this.estimateIntegratedSharedMemory(gpu, memoryInfo)
+                    : this.normalizeVRAM(gpu.vram || 0),
+                sharedMemory: this.isIntegratedGPU(gpu.model)
+                    ? this.estimateIntegratedSharedMemory(gpu, memoryInfo)
+                    : 0,
+                dedicatedMemory: this.normalizeVRAM(gpu.vram || 0),
                 vendor: gpu.vendor || this.inferVendorFromGPUModel(gpu.model, 'Unknown')
             })),
             displays: displays.length,
-            score: this.calculateGPUScore(primaryGPU)
+            score: this.calculateGPUScore(scoredGPU)
         };
     }
 
@@ -303,17 +367,40 @@ class HardwareDetector {
             const modelFromUnified = summary.gpuModel || fallbackModel || systemInfo.gpu.model;
             const vendor = this.inferVendorFromGPUModel(modelFromUnified, systemInfo.gpu.vendor);
             const isAppleUnified = primaryType === 'metal';
+            const integratedSharedMemory = Math.max(
+                Number(systemInfo.gpu.sharedMemory || 0),
+                ...(Array.isArray(unified.systemGpu?.gpus)
+                    ? unified.systemGpu.gpus
+                        .filter((gpu) => gpu?.type === 'integrated')
+                        .map((gpu) => Number(gpu?.memory?.total || gpu?.memoryTotal || 0))
+                    : [0])
+            );
 
             systemInfo.summary = {
-                ...summary
+                ...summary,
+                integratedSharedMemory: typeof summary.integratedSharedMemory === 'number'
+                    ? summary.integratedSharedMemory
+                    : integratedSharedMemory
             };
 
             systemInfo.gpu = {
                 ...systemInfo.gpu,
                 model: modelFromUnified,
                 vendor,
-                vram: isAppleUnified ? systemInfo.gpu.vram : (hasDedicatedGPU ? (totalVRAM || systemInfo.gpu.vram) : 0),
-                vramPerGPU: isAppleUnified ? (systemInfo.gpu.vramPerGPU || 0) : (perGPUVRAM || systemInfo.gpu.vramPerGPU || 0),
+                vram: isAppleUnified
+                    ? systemInfo.gpu.vram
+                    : (hasDedicatedGPU ? (totalVRAM || systemInfo.gpu.vram) : (integratedSharedMemory || systemInfo.gpu.vram || 0)),
+                vramPerGPU: isAppleUnified
+                    ? (systemInfo.gpu.vramPerGPU || 0)
+                    : (hasDedicatedGPU
+                        ? (perGPUVRAM || systemInfo.gpu.vramPerGPU || 0)
+                        : (integratedSharedMemory || systemInfo.gpu.vramPerGPU || systemInfo.gpu.vram || 0)),
+                sharedMemory: isAppleUnified
+                    ? (systemInfo.gpu.sharedMemory || 0)
+                    : (hasIntegratedGPU ? Math.max(integratedSharedMemory || 0, systemInfo.gpu.sharedMemory || 0) : 0),
+                dedicatedMemory: hasDedicatedGPU
+                    ? (totalVRAM || systemInfo.gpu.dedicatedMemory || systemInfo.gpu.vram || 0)
+                    : 0,
                 dedicated: hasDedicatedGPU,
                 gpuCount: summary.gpuCount || gpuCount,
                 isMultiGPU: Boolean(summary.isMultiGPU || gpuCount > 1),
@@ -557,13 +644,16 @@ class HardwareDetector {
 
         let score = 0;
         const model = gpu.model.toLowerCase();
-        const vram = gpu.vram || 0;
+        const integrated = this.isIntegratedGPU(gpu.model);
+        const vram = integrated
+            ? Math.min(gpu.sharedMemory || gpu.vram || 0, 2)
+            : (gpu.vram || 0);
 
 
         score += vram * 8;
 
 
-        if (!this.isIntegratedGPU(gpu.model)) {
+        if (!integrated) {
             score += 20;
         }
 
@@ -586,6 +676,10 @@ class HardwareDetector {
         else if (model.includes('apple m')) score += 15;
         else if (model.includes('r9700') || model.includes('ai pro r9700')) score += 23;
 
+        if (integrated) {
+            return Math.min(Math.round(score), 45);
+        }
+
         return Math.min(Math.round(score), 100);
     }
 

package/src/hardware/unified-detector.js

@@ -231,6 +231,7 @@ class UnifiedDetector {
             dedicatedGpuCount: 0,
             integratedGpuModels: [],
             dedicatedGpuModels: [],
+            integratedSharedMemory: 0,
             cpuModel: result.cpu?.brand || 'Unknown',
             systemRAM: require('os').totalmem() / (1024 ** 3)
         };
@@ -303,6 +304,7 @@ class UnifiedDetector {
         summary.dedicatedGpuCount = topology.dedicatedCount;
         summary.integratedGpuModels = topology.integratedModels;
         summary.dedicatedGpuModels = topology.dedicatedModels;
+        summary.integratedSharedMemory = topology.integratedSharedMemory;
         if (!summary.gpuModel) {
             summary.gpuModel = topology.primaryModel || null;
         }
@@ -355,6 +357,9 @@ class UnifiedDetector {
             models,
             integratedModels,
             dedicatedModels,
+            integratedSharedMemory: normalized
+                .filter((gpu) => gpu.type === 'integrated')
+                .reduce((max, gpu) => Math.max(max, Number(gpu?.memory?.total || 0)), 0),
             integratedCount: normalized.filter((gpu) => gpu.type === 'integrated').length,
             dedicatedCount: normalized.filter((gpu) => gpu.type === 'dedicated').length,
             hasIntegratedGPU: normalized.some((gpu) => gpu.type === 'integrated'),
@@ -412,6 +417,46 @@ class UnifiedDetector {
             .filter(Boolean);
     }
 
+    getSystemMemoryGB(memoryInfo) {
+        const totalBytes = Number(memoryInfo?.total || 0);
+        if (!Number.isFinite(totalBytes) || totalBytes <= 0) return 0;
+        return Math.max(1, Math.round(totalBytes / (1024 ** 3)));
+    }
+
+    estimateSystemSharedMemory(totalSystemGB, fallbackGB = 0) {
+        const fallback = Math.max(0, Number(fallbackGB) || 0);
+        if (!Number.isFinite(totalSystemGB) || totalSystemGB <= 0) {
+            return fallback;
+        }
+
+        return Math.max(fallback, Math.min(Math.max(1, Math.round(totalSystemGB / 2)), 16));
+    }
+
+    estimateIntegratedFallbackMemory(controller, memoryInfo) {
+        const dedicatedAperture = this.normalizeFallbackVRAM(controller?.vram || 0);
+        const explicitSharedCandidates = [
+            controller?.memoryTotal,
+            controller?.memory,
+            controller?.sharedMemory,
+            controller?.memoryShared,
+            controller?.memory?.shared,
+            controller?.memory?.total
+        ]
+            .map((value) => this.normalizeFallbackVRAM(value))
+            .filter((value) => value > dedicatedAperture);
+
+        if (explicitSharedCandidates.length > 0) {
+            return Math.max(...explicitSharedCandidates);
+        }
+
+        const totalSystemGB = this.getSystemMemoryGB(memoryInfo);
+        if (controller?.vramDynamic || dedicatedAperture <= 2) {
+            return this.estimateSystemSharedMemory(totalSystemGB, dedicatedAperture);
+        }
+
+        return dedicatedAperture;
+    }
+
     mergeGpuInventories(...gpuLists) {
         const normalizedLists = gpuLists.map((list) => this.normalizeGpuInventory(list));
         const primaryIndex = normalizedLists.findIndex((list) => list.length > 0);
@@ -433,6 +478,7 @@ class UnifiedDetector {
 
     async detectSystemGpuFallback() {
         const graphics = await si.graphics();
+        const memoryInfo = await si.mem().catch(() => null);
         const controllers = Array.isArray(graphics?.controllers) ? graphics.controllers : [];
 
         if (controllers.length === 0) {
@@ -455,7 +501,9 @@ class UnifiedDetector {
                 if (nameLower.includes('microsoft basic') || nameLower.includes('standard vga')) return null;
 
                 const isIntegrated = this.isIntegratedGPUModel(name);
-                let vram = this.normalizeFallbackVRAM(controller?.vram || controller?.memoryTotal || controller?.memory || 0);
+                let vram = isIntegrated
+                    ? this.estimateIntegratedFallbackMemory(controller, memoryInfo)
+                    : this.normalizeFallbackVRAM(controller?.vram || controller?.memoryTotal || controller?.memory || 0);
 
                 // For dedicated cards, estimate VRAM from model if runtime did not report memory.
                 if (!isIntegrated && vram === 0) {
@@ -821,6 +869,9 @@ class UnifiedDetector {
         else {
             if (summary.gpuModel && summary.hasIntegratedGPU && !summary.hasDedicatedGPU) {
                 const gpuDesc = summary.gpuInventory || summary.gpuModel;
+                if (summary.integratedSharedMemory > 0) {
+                    return `${gpuDesc} (${summary.integratedSharedMemory}GB shared memory, CPU backend) + ${summary.cpuModel}`;
+                }
                 return `${gpuDesc} (integrated/shared memory, CPU backend) + ${summary.cpuModel}`;
             }
             if (summary.gpuModel && summary.gpuCount > 0) {

package/src/index.js

@@ -1373,6 +1373,15 @@ class LLMChecker {
         // Detect PC platform (Windows/Linux)
         const normalizedPlatform = normalizePlatform(hardware.os?.platform || process.platform);
         const isPC = !isAppleSilicon && (normalizedPlatform === 'win32' || normalizedPlatform === '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|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)
+            : Boolean(!unified && (hardware.gpu?.dedicated || (vramGB > 0 && !hasIntegratedGPU)));
         const hasAVX512 = cpuModel.toLowerCase().includes('intel') && 
                          (cpuModel.includes('12th') || cpuModel.includes('13th') || cpuModel.includes('14th'));
         const hasAVX2 = cpuModel.toLowerCase().includes('intel') || 
@@ -1381,7 +1390,7 @@ class LLMChecker {
         // 1) Capacidad efectiva para pesos del modelo (45%)
         let effMem;
         
-        if (vramGB > 0 && !unified) {
+        if (hasDedicatedGPU && vramGB > 0 && !unified) {
             // Dedicated GPU path (Windows/Linux with discrete GPU)
             if (isPC) {
                 // PC-specific GPU memory calculation with offload support
@@ -1469,16 +1478,6 @@ class LLMChecker {
                   score >= 35 ? 'medium' :         // 35-54 for mid-range systems
                   score >= 20 ? 'low' : 'ultra_low'; // 20-34 for budget systems
         
-        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) {
             console.log(`GPU Model: "${gpuModel}"`);
@@ -1508,10 +1507,10 @@ class LLMChecker {
         } else if (!vramGB && !unified) {
             // Windows/Linux CPU-only - significativa limitación pero no extrema
             tier = this.bumpTier(tier, -1);
-        } else if (hasIntegratedGPU) {
+        } else if (hasIntegratedGPU && !hasDedicatedGPU) {
             // iGPU - limitada pero algo mejor que CPU puro
             tier = this.bumpTier(tier, -1);
-        } else if (vramGB > 0 && vramGB < 6) {
+        } else if (hasDedicatedGPU && vramGB > 0 && vramGB < 6) {
             // GPU dedicada con poca VRAM (GTX 1060, etc.)
             tier = this.bumpTier(tier, -1);
         }

package/src/models/deterministic-selector.js

@@ -751,40 +751,26 @@ class DeterministicModelSelector {
 
         return variants.map((variant) => {
             const variantTag = variant.tag || fallbackTag;
-            const paramsB = this.extractParamsFromString(
-                variant.size,
-                variantTag,
-                ollamaModel.main_size,
-                ollamaModel.model_identifier
-            );
+            const quant = this.resolveVariantQuantization(variant, variantTag);
+            const paramsB = this.resolveVariantParamsB(ollamaModel, variant, quant);
             const moeMetadata = this.extractMoEMetadata(ollamaModel, variant, paramsB, baseText);
-            const quant = this.normalizeQuantization(
-                variant.quantization ||
-                this.extractQuantizationFromTag(variantTag) ||
-                'Q4_K_M'
-            );
 
             const variantSizeGB = this.extractVariantSizeGB(variant, paramsB);
             const modalities = this.inferModalities(ollamaModel, variantTag);
             const modelTags = this.inferTagsForVariant(derivedTags, variant, variantTag);
             const sizeByQuant = {};
+            const variantIsCloud = this.isCloudVariantTag(variantTag);
 
             for (const sibling of variants) {
-                const siblingParams = this.extractParamsFromString(
-                    sibling.size,
-                    sibling.tag,
-                    ollamaModel.main_size,
-                    ollamaModel.model_identifier
-                );
+                const siblingTag = sibling.tag || fallbackTag;
+                if (this.isCloudVariantTag(siblingTag) !== variantIsCloud) continue;
+
+                const siblingQuant = this.resolveVariantQuantization(sibling, siblingTag);
+                const siblingParams = this.resolveVariantParamsB(ollamaModel, sibling, siblingQuant);
 
                 // Keep quantization map parameter-aware: don't blend 8B/70B/405B sizes.
                 if (Math.abs(siblingParams - paramsB) > 0.25) continue;
 
-                const siblingQuant = this.normalizeQuantization(
-                    sibling.quantization ||
-                    this.extractQuantizationFromTag(sibling.tag || '') ||
-                    quant
-                );
                 const siblingSize = this.extractVariantSizeGB(sibling, siblingParams);
                 if (!Number.isFinite(sizeByQuant[siblingQuant]) || siblingSize < sizeByQuant[siblingQuant]) {
                     sizeByQuant[siblingQuant] = siblingSize;
@@ -1003,17 +989,130 @@ class DeterministicModelSelector {
     }
 
     extractParamsFromString(...values) {
-        for (const value of values) {
-            if (typeof value === 'number' && Number.isFinite(value) && value > 0) {
-                return value;
+        const candidates = this.extractParameterCandidates(...values);
+        return candidates.length > 0 ? candidates[0] : null;
+    }
+
+    extractParameterCandidates(...values) {
+        const candidates = [];
+        const seen = new Set();
+
+        const pushCandidate = (value) => {
+            if (!Number.isFinite(value) || value <= 0) return;
+            const rounded = Math.round(value * 1000) / 1000;
+            const key = String(rounded);
+            if (seen.has(key)) return;
+            seen.add(key);
+            candidates.push(rounded);
+        };
+
+        const visit = (value) => {
+            if (typeof value === 'number') {
+                pushCandidate(value);
+                return;
+            }
+
+            if (Array.isArray(value)) {
+                value.forEach(visit);
+                return;
+            }
+
+            if (value && typeof value === 'object') {
+                Object.values(value).forEach(visit);
+                return;
+            }
+
+            if (typeof value !== 'string') return;
+
+            const regex = /(\d+\.?\d*)\s*([BbMm])/g;
+            for (const match of value.matchAll(regex)) {
+                const amount = parseFloat(match[1]);
+                const unit = match[2].toUpperCase();
+                pushCandidate(unit === 'M' ? amount / 1000 : amount);
             }
-            if (typeof value !== 'string') continue;
+        };
+
+        values.forEach(visit);
+        return candidates;
+    }
+
+    extractArtifactSizeGBFromValue(value) {
+        if (typeof value === 'number' && Number.isFinite(value) && value > 0) {
+            return value;
+        }
+        if (typeof value !== 'string') return null;
+
+        const match = value.match(/(\d+\.?\d*)\s*g(?:i)?b\b/i);
+        if (!match) return null;
+        return parseFloat(match[1]);
+    }
+
+    inferParamsFromArtifactSizeGB(sizeGB, quant = 'Q4_K_M') {
+        const normalizedQuant = this.normalizeQuantization(quant);
+        const bytesPerParam = {
+            'Q8_0': 1.05,
+            'Q6_K': 0.80,
+            'Q5_K_M': 0.68,
+            'Q4_K_M': 0.58,
+            'Q3_K': 0.48,
+            'Q2_K': 0.37
+        };
+        const bpp = bytesPerParam[normalizedQuant] || 0.58;
+        const inferred = sizeGB / bpp;
+        return Math.max(0.5, Math.round(inferred * 2) / 2);
+    }
+
+    isCloudVariantTag(tag = '') {
+        return /:cloud$/i.test(String(tag).trim());
+    }
+
+    resolveVariantQuantization(variant = {}, variantTag = '') {
+        const tagQuant = this.extractQuantizationFromTag(variantTag);
+        if (tagQuant) {
+            return this.normalizeQuantization(tagQuant);
+        }
+
+        return this.normalizeQuantization(
+            variant.quantization ||
+            variant.quant ||
+            'Q4_K_M'
+        );
+    }
 
-            const match = value.match(/(\d+\.?\d*)\s*([BbMm])/);
-            if (!match) continue;
-            const n = parseFloat(match[1]);
-            const unit = match[2].toUpperCase();
-            return unit === 'M' ? n / 1000 : n;
+    resolveVariantParamsB(ollamaModel = {}, variant = {}, quant = 'Q4_K_M') {
+        const explicitParams = this.extractParamsFromString(
+            variant.size,
+            variant.tag,
+            variant.label,
+            variant.name,
+            ollamaModel.model_identifier,
+            ollamaModel.model_name,
+            ollamaModel.parameter_size,
+            ollamaModel.parameter_count,
+            ollamaModel.parameters
+        );
+        if (Number.isFinite(explicitParams) && explicitParams > 0) {
+            return explicitParams;
+        }
+
+        const metadataCandidates = this.extractParameterCandidates(
+            ollamaModel.model_sizes,
+            ollamaModel.parameters,
+            ollamaModel.parameter_size,
+            ollamaModel.parameter_count
+        );
+        if (metadataCandidates.length > 0) {
+            return Math.max(...metadataCandidates);
+        }
+
+        const artifactSizeGB = this.extractVariantSizeGB(variant, null);
+        if (!this.isCloudVariantTag(variant.tag) && Number.isFinite(artifactSizeGB) && artifactSizeGB > 0) {
+            return this.inferParamsFromArtifactSizeGB(artifactSizeGB, quant);
+        }
+
+        const modelArtifactSizeGB = this.extractArtifactSizeGBFromValue(ollamaModel.main_size);
+        if (Number.isFinite(modelArtifactSizeGB) && modelArtifactSizeGB > 0) {
+            return this.inferParamsFromArtifactSizeGB(modelArtifactSizeGB, quant);
         }
 
         return 7;
@@ -1038,6 +1137,7 @@ class DeterministicModelSelector {
     extractVariantSizeGB(variant, paramsB) {
         const candidate = Number(variant.real_size_gb ?? variant.estimated_size_gb ?? NaN);
         if (Number.isFinite(candidate) && candidate > 0) return candidate;
+        if (!Number.isFinite(paramsB) || paramsB <= 0) return 0.5;
         return Math.max(0.5, Math.round((paramsB * 0.58 + 0.5) * 10) / 10);
     }
 
@@ -2049,6 +2149,20 @@ class DeterministicModelSelector {
     }
 
     mapHardwareTier(hardware = {}) {
+        const summary = hardware?.summary || {};
+        const effectiveMemory = Number(summary.effectiveMemory);
+        const speedCoefficient = Number(summary.speedCoefficient);
+        if (Number.isFinite(effectiveMemory) && effectiveMemory > 0 && Number.isFinite(speedCoefficient)) {
+            if (effectiveMemory >= 80 && speedCoefficient >= 300) return 'ultra_high';
+            if (effectiveMemory >= 48 && speedCoefficient >= 200) return 'very_high';
+            if (effectiveMemory >= 24 && speedCoefficient >= 150) return 'high';
+            if (effectiveMemory >= 16 && speedCoefficient >= 100) return 'medium_high';
+            if (effectiveMemory >= 12 && speedCoefficient >= 80) return 'medium';
+            if (effectiveMemory >= 8 && speedCoefficient >= 50) return 'medium_low';
+            if (effectiveMemory >= 6 && speedCoefficient >= 30) return 'low';
+            return 'ultra_low';
+        }
+
         let ram, cores;
 
         if (hardware?.memory?.totalGB) {