llm-checker 3.5.2 → 3.5.3

package/bin/enhanced_cli.js

@@ -65,6 +65,7 @@ const COMMAND_HEADER_LABELS = {
     demo: 'Demo',
     ollama: 'Ollama Integration',
     recommend: 'Recommendations',
+    simulate: 'Hardware Simulation',
     'list-models': 'Model Catalog'
 };
 
@@ -2938,6 +2939,11 @@ program
     .option('--performance-test', 'Run performance benchmarks')
     .option('--show-ollama-analysis', 'Show detailed Ollama model analysis')
     .option('--no-verbose', 'Disable step-by-step progress display')
+    .option('--simulate <profile>', 'Simulate a hardware profile instead of detecting real hardware (use "list" to see profiles)')
+    .option('--gpu <model>', 'Custom GPU model for simulation (e.g., "RTX 5060", "RX 7800 XT")')
+    .option('--ram <gb>', 'Custom RAM in GB for simulation (e.g., 32)')
+    .option('--cpu <model>', 'Custom CPU model for simulation (e.g., "AMD Ryzen 7 5700X")')
+    .option('--vram <gb>', 'Override GPU VRAM in GB for simulation (auto-detected if omitted)')
     .addHelpText(
         'after',
         `
@@ -2946,6 +2952,12 @@ Enterprise policy examples:
   $ llm-checker check --policy ./policy.yaml --use-case coding --runtime vllm
   $ llm-checker check --policy ./policy.yaml --include-cloud --max-size 24B
 
+Hardware simulation:
+  $ llm-checker check --simulate list
+  $ llm-checker check --simulate rtx4090
+  $ llm-checker check --simulate m4pro24 --use-case coding
+  $ llm-checker check --gpu "RTX 5060" --ram 32 --cpu "AMD Ryzen 7 5700X"
+
 Policy scope:
   - Evaluates all compatible and marginal candidates discovered during analysis
   - Not limited to the top --limit results shown in output
@@ -2958,7 +2970,57 @@ Policy scope:
             const verboseEnabled = options.verbose !== false;
             const checker = new (getLLMChecker())({ verbose: verboseEnabled });
             const policyConfig = options.policy ? loadPolicyConfiguration(options.policy) : null;
-            
+
+            // Handle hardware simulation (preset profile or custom flags)
+            const hasCustomHwFlags = options.gpu || options.ram || options.cpu || options.vram;
+            if (options.simulate || hasCustomHwFlags) {
+                const { buildFullHardwareObject, buildCustomHardwareObject, getProfile, listProfiles } = require('../src/hardware/profiles');
+                if (options.simulate === 'list') {
+                    console.log(chalk.cyan.bold('\n  Available Hardware Profiles:\n'));
+                    listProfiles().forEach(line => console.log(line));
+                    console.log('');
+                    return;
+                }
+                let simulatedHardware;
+                let displayLabel;
+                if (hasCustomHwFlags) {
+                    const ramValue = options.ram ? parseInt(options.ram) : undefined;
+                    const vramValue = options.vram ? parseInt(options.vram) : undefined;
+                    if (options.vram && !options.gpu) {
+                        console.error(chalk.red('\n  --vram requires --gpu in custom hardware mode (e.g., --gpu "RTX 4090" --vram 24).'));
+                        process.exit(1);
+                    }
+                    if (options.ram && (!Number.isFinite(ramValue) || ramValue <= 0)) {
+                        console.error(chalk.red(`\n  Invalid --ram value: "${options.ram}". Must be a positive number (e.g., 32).`));
+                        process.exit(1);
+                    }
+                    if (options.vram && (!Number.isFinite(vramValue) || vramValue <= 0)) {
+                        console.error(chalk.red(`\n  Invalid --vram value: "${options.vram}". Must be a positive number (e.g., 8).`));
+                        process.exit(1);
+                    }
+                    simulatedHardware = buildCustomHardwareObject({
+                        gpu: options.gpu || null,
+                        ram: ramValue,
+                        cpu: options.cpu || null,
+                        vram: vramValue
+                    });
+                    displayLabel = simulatedHardware._displayName;
+                } else {
+                    const profile = getProfile(options.simulate);
+                    if (!profile) {
+                        console.error(chalk.red(`\n  Unknown profile: ${options.simulate}`));
+                        console.log(chalk.gray('\n  Available profiles:'));
+                        listProfiles().forEach(line => console.log(line));
+                        console.log('');
+                        process.exit(1);
+                    }
+                    simulatedHardware = buildFullHardwareObject(options.simulate);
+                    displayLabel = profile.displayName;
+                }
+                checker.setSimulatedHardware(simulatedHardware);
+                console.log(chalk.magenta.bold(`\n  SIMULATION MODE: ${displayLabel}\n`));
+            }
+
             // If verbose is disabled, show simple loading message
             if (!verboseEnabled) {
                 process.stdout.write(chalk.gray('Analyzing your system...'));
@@ -3429,6 +3491,11 @@ program
     .option('--optimize <profile>', 'Optimization profile (balanced|speed|quality|context|coding)', 'balanced')
     .option('--no-verbose', 'Disable step-by-step progress display')
     .option('--policy <file>', 'Evaluate recommendations against a policy file')
+    .option('--simulate <profile>', 'Simulate a hardware profile instead of detecting real hardware (use "list" to see profiles)')
+    .option('--gpu <model>', 'Custom GPU model for simulation (e.g., "RTX 5060", "RX 7800 XT")')
+    .option('--ram <gb>', 'Custom RAM in GB for simulation (e.g., 32)')
+    .option('--cpu <model>', 'Custom CPU model for simulation (e.g., "AMD Ryzen 7 5700X")')
+    .option('--vram <gb>', 'Override GPU VRAM in GB for simulation (auto-detected if omitted)')
     .option(
         '--calibrated [file]',
         'Use calibrated routing policy (optional file path; defaults to ~/.llm-checker/calibration-policy.{yaml,yml,json})'
@@ -3441,6 +3508,11 @@ Enterprise policy examples:
   $ llm-checker recommend --policy ./policy.yaml --category coding
   $ llm-checker recommend --policy ./policy.yaml --no-verbose
 
+Hardware simulation:
+  $ llm-checker recommend --simulate rtx4090
+  $ llm-checker recommend --simulate m4pro24 --category coding
+  $ llm-checker recommend --gpu "RTX 5060" --ram 32 --cpu "AMD Ryzen 7 5700X"
+
 Calibrated routing examples:
   $ llm-checker recommend --calibrated --category coding
   $ llm-checker recommend --calibrated ./calibration-policy.yaml --category reasoning
@@ -3452,6 +3524,57 @@ Calibrated routing examples:
         try {
             const verboseEnabled = options.verbose !== false;
             const checker = new (getLLMChecker())({ verbose: verboseEnabled });
+
+            // Handle hardware simulation (preset profile or custom flags)
+            const hasCustomHwFlags = options.gpu || options.ram || options.cpu || options.vram;
+            if (options.simulate || hasCustomHwFlags) {
+                const { buildFullHardwareObject, buildCustomHardwareObject, getProfile, listProfiles } = require('../src/hardware/profiles');
+                if (options.simulate === 'list') {
+                    console.log(chalk.cyan.bold('\n  Available Hardware Profiles:\n'));
+                    listProfiles().forEach(line => console.log(line));
+                    console.log('');
+                    return;
+                }
+                let simulatedHardware;
+                let displayLabel;
+                if (hasCustomHwFlags) {
+                    const ramValue = options.ram ? parseInt(options.ram) : undefined;
+                    const vramValue = options.vram ? parseInt(options.vram) : undefined;
+                    if (options.vram && !options.gpu) {
+                        console.error(chalk.red('\n  --vram requires --gpu in custom hardware mode (e.g., --gpu "RTX 4090" --vram 24).'));
+                        process.exit(1);
+                    }
+                    if (options.ram && (!Number.isFinite(ramValue) || ramValue <= 0)) {
+                        console.error(chalk.red(`\n  Invalid --ram value: "${options.ram}". Must be a positive number (e.g., 32).`));
+                        process.exit(1);
+                    }
+                    if (options.vram && (!Number.isFinite(vramValue) || vramValue <= 0)) {
+                        console.error(chalk.red(`\n  Invalid --vram value: "${options.vram}". Must be a positive number (e.g., 8).`));
+                        process.exit(1);
+                    }
+                    simulatedHardware = buildCustomHardwareObject({
+                        gpu: options.gpu || null,
+                        ram: ramValue,
+                        cpu: options.cpu || null,
+                        vram: vramValue
+                    });
+                    displayLabel = simulatedHardware._displayName;
+                } else {
+                    const profile = getProfile(options.simulate);
+                    if (!profile) {
+                        console.error(chalk.red(`\n  Unknown profile: ${options.simulate}`));
+                        console.log(chalk.gray('\n  Available profiles:'));
+                        listProfiles().forEach(line => console.log(line));
+                        console.log('');
+                        process.exit(1);
+                    }
+                    simulatedHardware = buildFullHardwareObject(options.simulate);
+                    displayLabel = profile.displayName;
+                }
+                checker.setSimulatedHardware(simulatedHardware);
+                console.log(chalk.magenta.bold(`\n  SIMULATION MODE: ${displayLabel}\n`));
+            }
+
             const routingPreference = resolveRoutingPolicyPreference({
                 policyOption: options.policy,
                 calibratedOption: options.calibrated,
@@ -3524,6 +3647,191 @@ Calibrated routing examples:
         }
     });
 
+program
+    .command('simulate')
+    .description('Simulate hardware profiles to see compatible LLM models for different systems')
+    .option('-p, --profile <name>', 'Hardware profile to simulate (e.g., rtx4090, m4pro24, h100)')
+    .option('-l, --list', 'List all available hardware profiles')
+    .option('--gpu <model>', 'Custom GPU model (e.g., "RTX 5060", "RX 7800 XT", "Apple M4 Pro")')
+    .option('--ram <gb>', 'Custom RAM in GB (e.g., 32)')
+    .option('--cpu <model>', 'Custom CPU model (e.g., "AMD Ryzen 7 5700X")')
+    .option('--vram <gb>', 'Override GPU VRAM in GB (auto-detected from GPU model if omitted)')
+    .option('-u, --use-case <case>', 'Specify use case', 'general')
+    .option('--optimize <profile>', 'Optimization profile (balanced|speed|quality|context|coding)', 'balanced')
+    .option('--limit <number>', 'Number of compatible models to show (default: 1)', '1')
+    .option('--no-verbose', 'Disable step-by-step progress display')
+    .addHelpText(
+        'after',
+        `
+Preset profiles:
+  $ llm-checker simulate --list
+  $ llm-checker simulate
+  $ llm-checker simulate -p rtx4090
+  $ llm-checker simulate -p m4pro24 --use-case coding
+
+Custom hardware:
+  $ llm-checker simulate --gpu "RTX 5060" --ram 32 --cpu "AMD Ryzen 7 5700X"
+  $ llm-checker simulate --gpu "RTX 4090" --ram 64
+  $ llm-checker simulate --gpu "RX 7800 XT" --ram 32 --vram 16
+  $ llm-checker simulate --ram 16
+`
+    )
+    .action(async (options) => {
+        const { buildFullHardwareObject, buildCustomHardwareObject, getProfile, getProfilesByCategory, listProfiles, CATEGORY_LABELS } = require('../src/hardware/profiles');
+
+        // List mode
+        if (options.list) {
+            console.log(chalk.cyan.bold('\n  Available Hardware Profiles:\n'));
+            listProfiles().forEach(line => console.log(line));
+            console.log('');
+            return;
+        }
+
+        let simulatedHardware;
+        let displayLabel;
+
+        // Custom hardware mode: --gpu, --ram, --cpu, --vram
+        const hasCustomFlags = options.gpu || options.ram || options.cpu || options.vram;
+        if (hasCustomFlags) {
+            const ramValue = options.ram ? parseInt(options.ram) : undefined;
+            const vramValue = options.vram ? parseInt(options.vram) : undefined;
+            if (options.vram && !options.gpu) {
+                console.error(chalk.red('\n  --vram requires --gpu in custom hardware mode (e.g., --gpu "RTX 4090" --vram 24).'));
+                process.exit(1);
+            }
+            if (options.ram && (!Number.isFinite(ramValue) || ramValue <= 0)) {
+                console.error(chalk.red(`\n  Invalid --ram value: "${options.ram}". Must be a positive number (e.g., 32).`));
+                process.exit(1);
+            }
+            if (options.vram && (!Number.isFinite(vramValue) || vramValue <= 0)) {
+                console.error(chalk.red(`\n  Invalid --vram value: "${options.vram}". Must be a positive number (e.g., 8).`));
+                process.exit(1);
+            }
+            simulatedHardware = buildCustomHardwareObject({
+                gpu: options.gpu || null,
+                ram: ramValue,
+                cpu: options.cpu || null,
+                vram: vramValue
+            });
+            displayLabel = simulatedHardware._displayName;
+        } else {
+            // Preset profile mode
+            if (!options.profile) {
+                // Guard against non-interactive environments
+                if (!process.stdin.isTTY || !process.stdout.isTTY) {
+                    console.error(chalk.red('\n  No hardware profile specified.'));
+                    console.log(chalk.gray('  Use --profile <name>, --gpu/--ram/--cpu flags, or --list to see profiles.\n'));
+                    process.exit(1);
+                }
+                // Interactive selection
+                try {
+                    const inquirer = require('inquirer');
+                    const categories = getProfilesByCategory();
+                    const choices = [];
+
+                    for (const [category, profiles] of Object.entries(categories)) {
+                        const label = CATEGORY_LABELS[category] || category;
+                        choices.push(new inquirer.Separator(chalk.gray(`── ${label} ──`)));
+                        for (const [key, profile] of Object.entries(profiles)) {
+                            const vramLabel = profile.gpu.unified
+                                ? `${profile.memory.total}GB unified`
+                                : (profile.gpu.vram > 0 ? `${profile.gpu.vram}GB VRAM` : 'No GPU');
+                            const ramLabel = profile.gpu.unified ? '' : ` / ${profile.memory.total}GB RAM`;
+                            choices.push({
+                                name: `${profile.displayName}  ${chalk.gray(`(${vramLabel}${ramLabel})`)}`,
+                                value: key
+                            });
+                        }
+                    }
+
+                    const { selectedProfile } = await inquirer.prompt([{
+                        type: 'list',
+                        name: 'selectedProfile',
+                        message: 'Select a hardware profile to simulate:',
+                        choices,
+                        pageSize: 20
+                    }]);
+                    options.profile = selectedProfile;
+                } catch (error) {
+                    if (error.isTtyError) {
+                        console.error(chalk.red('Interactive mode requires a TTY terminal.'));
+                        console.log(chalk.gray('Use --profile <name>, --gpu/--ram flags, or --list to see available profiles.'));
+                        process.exit(1);
+                    }
+                    throw error;
+                }
+            }
+
+            // Validate profile
+            const profile = getProfile(options.profile);
+            if (!profile) {
+                console.error(chalk.red(`\n  Unknown profile: ${options.profile}`));
+                console.log(chalk.gray('\n  Available profiles:'));
+                listProfiles().forEach(line => console.log(line));
+                console.log('');
+                process.exit(1);
+            }
+
+            simulatedHardware = buildFullHardwareObject(options.profile);
+            displayLabel = profile.displayName;
+        }
+
+        showAsciiArt('simulate');
+
+        try {
+            const verboseEnabled = options.verbose !== false;
+            const checker = new (getLLMChecker())({ verbose: verboseEnabled });
+            checker.setSimulatedHardware(simulatedHardware);
+
+            console.log(chalk.magenta.bold(`  SIMULATION MODE: ${displayLabel}\n`));
+
+            if (!verboseEnabled) {
+                process.stdout.write(chalk.gray('Analyzing simulated hardware...'));
+            }
+
+            const hardware = await checker.getSystemInfo();
+
+            const normalizeUseCase = (useCase = '') => {
+                const alias = useCase.toLowerCase().trim();
+                const useCaseMap = {
+                    'embed': 'embeddings', 'embedding': 'embeddings', 'embeddings': 'embeddings',
+                    'embedings': 'embeddings', 'talk': 'chat', 'chat': 'chat', 'talking': 'chat'
+                };
+                return useCaseMap[alias] || alias || 'general';
+            };
+
+            const analysis = await checker.analyze({
+                useCase: normalizeUseCase(options.useCase),
+                limit: parseInt(options.limit) || 10,
+                runtime: 'ollama'
+            });
+
+            if (!verboseEnabled) {
+                console.log(chalk.green(' done'));
+            }
+
+            displaySimplifiedSystemInfo(hardware);
+
+            const normalizedUseCase = normalizeUseCase(options.useCase);
+            const limit = parseInt(options.limit) || 1;
+            const recommendedModels = await displayModelRecommendations(
+                analysis,
+                hardware,
+                normalizedUseCase,
+                limit,
+                'ollama'
+            );
+            await displayQuickStartCommands(analysis, recommendedModels[0], recommendedModels, 'ollama');
+
+        } catch (error) {
+            console.error(chalk.red('\nError:'), error.message);
+            if (process.env.DEBUG) {
+                console.error(error.stack);
+            }
+            process.exit(1);
+        }
+    });
+
 program
     .command('list-models')
     .description('List all models from Ollama database')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-checker",
-  "version": "3.5.2",
+  "version": "3.5.3",
   "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",
@@ -47,7 +47,7 @@
     "inquirer": "^8.2.6",
     "node-fetch": "^2.7.0",
     "ora": "^5.4.1",
-    "systeminformation": "^5.21.0",
+    "systeminformation": "^5.31.1",
     "table": "^6.8.1",
     "yaml": "^2.8.1",
     "zod": "^3.23.0"
@@ -55,9 +55,16 @@
   "optionalDependencies": {
     "sql.js": "^1.14.0"
   },
+  "overrides": {
+    "ajv": "^8.18.0",
+    "hono": "^4.11.10",
+    "glob": "^13.0.0",
+    "minimatch": "^10.2.2",
+    "test-exclude": "^7.0.1"
+  },
   "devDependencies": {
     "@types/node": "^20.0.0",
-    "jest": "^29.7.0"
+    "jest": "^30.2.0"
   },
   "keywords": [
     "llm",

package/src/hardware/detector.js

@@ -7,9 +7,22 @@ class HardwareDetector {
         this.cacheExpiry = 5 * 60 * 1000;
         this.cacheTime = 0;
         this.unifiedDetector = new UnifiedDetector();
+        this._simulatedHardware = null;
+    }
+
+    setSimulatedHardware(hardwareObject) {
+        this._simulatedHardware = hardwareObject;
+    }
+
+    clearSimulatedHardware() {
+        this._simulatedHardware = null;
     }
 
     async getSystemInfo(forceFresh = false) {
+        // Return simulated hardware if set (bypasses real detection)
+        if (this._simulatedHardware) {
+            return this._simulatedHardware;
+        }
 
         if (!forceFresh && this.cache && (Date.now() - this.cacheTime < this.cacheExpiry)) {
             return this.cache;

package/src/hardware/profiles.js

@@ -0,0 +1,484 @@
+const HardwareSpecs = require('./specs');
+
+const specs = new HardwareSpecs();
+
+// Curated hardware profiles for simulation
+const HARDWARE_PROFILES = {
+    // NVIDIA Data Center
+    h100: {
+        displayName: 'NVIDIA H100 80GB (Data Center)',
+        category: 'data_center',
+        gpu: { model: 'NVIDIA H100', vendor: 'NVIDIA', vram: 80, dedicated: true },
+        cpu: { brand: 'AMD EPYC 9654', cores: 96, physicalCores: 96, speed: 2.4, architecture: 'x86_64' },
+        memory: { total: 256 },
+        backend: 'cuda',
+        os: { platform: 'linux' }
+    },
+    a100: {
+        displayName: 'NVIDIA A100 80GB (Data Center)',
+        category: 'data_center',
+        gpu: { model: 'NVIDIA A100', vendor: 'NVIDIA', vram: 80, dedicated: true },
+        cpu: { brand: 'AMD EPYC 7763', cores: 64, physicalCores: 64, speed: 2.45, architecture: 'x86_64' },
+        memory: { total: 128 },
+        backend: 'cuda',
+        os: { platform: 'linux' }
+    },
+
+    // NVIDIA Desktop
+    rtx4090: {
+        displayName: 'NVIDIA RTX 4090 (Desktop)',
+        category: 'nvidia_desktop',
+        gpu: { model: 'NVIDIA GeForce RTX 4090', vendor: 'NVIDIA', vram: 24, dedicated: true },
+        cpu: { brand: 'AMD Ryzen 9 7950X', cores: 16, physicalCores: 16, speed: 4.5, architecture: 'x86_64' },
+        memory: { total: 64 },
+        backend: 'cuda',
+        os: { platform: 'linux' }
+    },
+    rtx3090: {
+        displayName: 'NVIDIA RTX 3090 (Desktop)',
+        category: 'nvidia_desktop',
+        gpu: { model: 'NVIDIA GeForce RTX 3090', vendor: 'NVIDIA', vram: 24, dedicated: true },
+        cpu: { brand: 'AMD Ryzen 9 5950X', cores: 16, physicalCores: 16, speed: 3.4, architecture: 'x86_64' },
+        memory: { total: 64 },
+        backend: 'cuda',
+        os: { platform: 'linux' }
+    },
+    rtx4070ti: {
+        displayName: 'NVIDIA RTX 4070 Ti (Desktop)',
+        category: 'nvidia_desktop',
+        gpu: { model: 'NVIDIA GeForce RTX 4070 Ti', vendor: 'NVIDIA', vram: 12, dedicated: true },
+        cpu: { brand: 'Intel Core i7-13700K', cores: 16, physicalCores: 16, speed: 3.4, architecture: 'x86_64' },
+        memory: { total: 32 },
+        backend: 'cuda',
+        os: { platform: 'linux' }
+    },
+    rtx3060: {
+        displayName: 'NVIDIA RTX 3060 (Desktop)',
+        category: 'nvidia_desktop',
+        gpu: { model: 'NVIDIA GeForce RTX 3060', vendor: 'NVIDIA', vram: 12, dedicated: true },
+        cpu: { brand: 'Intel Core i5-12600K', cores: 10, physicalCores: 10, speed: 3.7, architecture: 'x86_64' },
+        memory: { total: 32 },
+        backend: 'cuda',
+        os: { platform: 'linux' }
+    },
+
+    // Apple Silicon
+    m4max48: {
+        displayName: 'Apple M4 Max 48GB',
+        category: 'apple_silicon',
+        gpu: { model: 'Apple M4 Max', vendor: 'Apple', vram: 0, dedicated: false, unified: true },
+        cpu: { brand: 'Apple M4 Max', cores: 16, physicalCores: 16, speed: 4.5, architecture: 'Apple Silicon' },
+        memory: { total: 48 },
+        backend: 'metal',
+        os: { platform: 'darwin' }
+    },
+    m4pro24: {
+        displayName: 'Apple M4 Pro 24GB',
+        category: 'apple_silicon',
+        gpu: { model: 'Apple M4 Pro', vendor: 'Apple', vram: 0, dedicated: false, unified: true },
+        cpu: { brand: 'Apple M4 Pro', cores: 14, physicalCores: 14, speed: 4.5, architecture: 'Apple Silicon' },
+        memory: { total: 24 },
+        backend: 'metal',
+        os: { platform: 'darwin' }
+    },
+    m3_16: {
+        displayName: 'Apple M3 16GB',
+        category: 'apple_silicon',
+        gpu: { model: 'Apple M3', vendor: 'Apple', vram: 0, dedicated: false, unified: true },
+        cpu: { brand: 'Apple M3', cores: 8, physicalCores: 8, speed: 4.0, architecture: 'Apple Silicon' },
+        memory: { total: 16 },
+        backend: 'metal',
+        os: { platform: 'darwin' }
+    },
+    m1_16: {
+        displayName: 'Apple M1 16GB',
+        category: 'apple_silicon',
+        gpu: { model: 'Apple M1', vendor: 'Apple', vram: 0, dedicated: false, unified: true },
+        cpu: { brand: 'Apple M1', cores: 8, physicalCores: 8, speed: 3.2, architecture: 'Apple Silicon' },
+        memory: { total: 16 },
+        backend: 'metal',
+        os: { platform: 'darwin' }
+    },
+
+    // AMD Desktop
+    rx7900xtx: {
+        displayName: 'AMD RX 7900 XTX (Desktop)',
+        category: 'amd_desktop',
+        gpu: { model: 'AMD Radeon RX 7900 XTX', vendor: 'AMD', vram: 24, dedicated: true },
+        cpu: { brand: 'AMD Ryzen 9 7900X', cores: 12, physicalCores: 12, speed: 4.7, architecture: 'x86_64' },
+        memory: { total: 64 },
+        backend: 'rocm',
+        os: { platform: 'linux' }
+    },
+
+    // CPU Only
+    cpu_high: {
+        displayName: 'CPU Only (32GB RAM)',
+        category: 'cpu_only',
+        gpu: { model: '', vendor: '', vram: 0, dedicated: false },
+        cpu: { brand: 'Intel Core i9-13900K', cores: 24, physicalCores: 24, speed: 3.0, architecture: 'x86_64' },
+        memory: { total: 32 },
+        backend: 'cpu',
+        os: { platform: 'linux' }
+    },
+    cpu_mid: {
+        displayName: 'CPU Only (16GB RAM)',
+        category: 'cpu_only',
+        gpu: { model: '', vendor: '', vram: 0, dedicated: false },
+        cpu: { brand: 'AMD Ryzen 7 5800X', cores: 8, physicalCores: 8, speed: 3.8, architecture: 'x86_64' },
+        memory: { total: 16 },
+        backend: 'cpu',
+        os: { platform: 'linux' }
+    },
+    cpu_low: {
+        displayName: 'CPU Only (8GB RAM)',
+        category: 'cpu_only',
+        gpu: { model: '', vendor: '', vram: 0, dedicated: false },
+        cpu: { brand: 'Intel Core i5-12600K', cores: 10, physicalCores: 10, speed: 3.7, architecture: 'x86_64' },
+        memory: { total: 8 },
+        backend: 'cpu',
+        os: { platform: 'linux' }
+    }
+};
+
+const CATEGORY_LABELS = {
+    data_center: 'Data Center',
+    nvidia_desktop: 'NVIDIA Desktop',
+    apple_silicon: 'Apple Silicon',
+    amd_desktop: 'AMD Desktop',
+    cpu_only: 'CPU Only'
+};
+
+function buildFullHardwareObject(profileKey) {
+    const profile = HARDWARE_PROFILES[profileKey];
+    if (!profile) return null;
+
+    const isApple = profile.os.platform === 'darwin';
+    const isUnified = Boolean(profile.gpu.unified);
+    const totalRAM = profile.memory.total;
+    const vram = profile.gpu.vram;
+
+    // Compute effective memory (matches unified-detector logic)
+    const effectiveMemory = isUnified
+        ? totalRAM
+        : (vram > 0 ? vram : Math.round(totalRAM * 0.7));
+
+    // Get scores from HardwareSpecs where available
+    const cpuSpecs = specs.getCPUScore(profile.cpu.brand);
+    const gpuSpecs = profile.gpu.model ? specs.getGPUScore(profile.gpu.model) : { score: 0 };
+
+    // Simulate ~60% free memory
+    const freeRAM = Math.round(totalRAM * 0.6);
+    const usedRAM = totalRAM - freeRAM;
+
+    // Build the full hardware object (Shape A - matches HardwareDetector.getSystemInfo() output)
+    const hardware = {
+        cpu: {
+            brand: profile.cpu.brand,
+            manufacturer: isApple ? 'Apple' : (profile.cpu.brand.includes('Intel') ? 'Intel' : 'AMD'),
+            family: 'Unknown',
+            model: 'Unknown',
+            speed: profile.cpu.speed,
+            speedMax: profile.cpu.speed,
+            cores: profile.cpu.cores,
+            physicalCores: profile.cpu.physicalCores,
+            processors: 1,
+            cache: { l1d: 0, l1i: 0, l2: 0, l3: 0 },
+            architecture: profile.cpu.architecture,
+            score: cpuSpecs.score || 70
+        },
+        memory: {
+            total: totalRAM,
+            free: freeRAM,
+            used: usedRAM,
+            available: freeRAM,
+            usagePercent: Math.round((usedRAM / totalRAM) * 100),
+            swapTotal: 0,
+            swapUsed: 0,
+            score: totalRAM >= 64 ? 55 : (totalRAM >= 32 ? 50 : (totalRAM >= 16 ? 40 : 25))
+        },
+        gpu: {
+            model: profile.gpu.model || 'No GPU detected',
+            vendor: profile.gpu.vendor || 'Unknown',
+            vram: vram,
+            vramPerGPU: vram,
+            vramDynamic: false,
+            dedicated: profile.gpu.dedicated,
+            driverVersion: 'Simulated',
+            gpuCount: 1,
+            isMultiGPU: false,
+            all: profile.gpu.model ? [{
+                model: profile.gpu.model,
+                vram: vram,
+                vendor: profile.gpu.vendor
+            }] : [],
+            displays: 1,
+            score: gpuSpecs.score || 0,
+            unified: isUnified,
+            backend: profile.backend
+        },
+        system: {
+            manufacturer: isApple ? 'Apple' : 'Simulated System',
+            model: profile.displayName,
+            version: 'Simulated'
+        },
+        os: {
+            platform: profile.os.platform,
+            distro: isApple ? 'macOS' : 'Linux',
+            release: 'Simulated',
+            codename: 'Simulated',
+            kernel: 'Simulated',
+            arch: profile.cpu.architecture === 'Apple Silicon' ? 'arm64' : 'x64',
+            hostname: 'simulated-host',
+            logofile: ''
+        },
+        timestamp: Date.now(),
+
+        // Shape B - for ScoringEngine / test compatibility
+        summary: {
+            bestBackend: profile.backend,
+            gpuModel: profile.gpu.model,
+            effectiveMemory: effectiveMemory,
+            systemRAM: totalRAM,
+            totalVRAM: vram
+        }
+    };
+
+    // Add CPU capabilities for scoring engine
+    hardware.cpu.capabilities = {};
+    if (profile.cpu.architecture === 'Apple Silicon') {
+        hardware.cpu.capabilities.neon = true;
+    } else {
+        hardware.cpu.capabilities.avx2 = true;
+        if (profile.cpu.cores >= 64) {
+            hardware.cpu.capabilities.avx512 = true;
+        }
+    }
+
+    return hardware;
+}
+
+function inferGpuDetails(gpuName) {
+    if (!gpuName) return { model: '', vendor: '', vram: 0, dedicated: false, unified: false, backend: 'cpu', platform: 'linux' };
+
+    const lower = gpuName.toLowerCase();
+    let vendor = 'Unknown';
+    let dedicated = true;
+    let unified = false;
+    let backend = 'cuda';
+    let platform = 'linux';
+
+    if (lower.includes('nvidia') || lower.includes('rtx') || lower.includes('gtx') || lower.includes('geforce')) {
+        vendor = 'NVIDIA';
+        backend = 'cuda';
+    } else if (lower.includes('amd') || lower.includes('radeon') || lower.includes('rx ')) {
+        vendor = 'AMD';
+        backend = 'rocm';
+    } else if (lower.includes('apple') || /\bm[1-9]\b/.test(lower)) {
+        vendor = 'Apple';
+        backend = 'metal';
+        platform = 'darwin';
+        dedicated = false;
+        unified = true;
+    } else if (lower.includes('intel') && (lower.includes('arc') || lower.includes('iris') || lower.includes('uhd'))) {
+        vendor = 'Intel';
+        backend = 'cpu';
+        dedicated = lower.includes('arc');
+    }
+
+    // Normalize model name to match what estimateVRAMFromModel expects
+    let model = gpuName;
+    if (vendor === 'NVIDIA' && !lower.includes('nvidia')) {
+        model = `NVIDIA GeForce ${gpuName}`;
+    }
+
+    // Use HardwareDetector's VRAM estimation logic
+    const HardwareDetector = require('./detector');
+    const detector = new HardwareDetector();
+    const estimatedVram = detector.estimateVRAMFromModel(model);
+
+    return { model, vendor, vram: estimatedVram, dedicated, unified, backend, platform };
+}
+
+function inferCpuDetails(cpuName) {
+    if (!cpuName) return { brand: 'Unknown CPU', cores: 8, physicalCores: 8, speed: 3.5, architecture: 'x86_64', manufacturer: 'Unknown' };
+
+    const lower = cpuName.toLowerCase();
+    const cpuSpecs = specs.getCPUScore(cpuName);
+    let manufacturer = 'Unknown';
+    let architecture = 'x86_64';
+
+    if (lower.includes('apple') || /\bm[1-9]\b/.test(lower)) {
+        manufacturer = 'Apple';
+        architecture = 'Apple Silicon';
+    } else if (lower.includes('intel')) {
+        manufacturer = 'Intel';
+    } else if (lower.includes('amd') || lower.includes('ryzen') || lower.includes('epyc')) {
+        manufacturer = 'AMD';
+    }
+
+    return {
+        brand: cpuName,
+        cores: cpuSpecs.cores || 8,
+        physicalCores: cpuSpecs.cores || 8,
+        speed: 3.5,
+        architecture,
+        manufacturer
+    };
+}
+
+function buildCustomHardwareObject({ gpu, ram, cpu, vram: overrideVram }) {
+    const gpuDetails = inferGpuDetails(gpu);
+    const cpuDetails = inferCpuDetails(cpu);
+
+    const totalRAM = ram || 16;
+    const vram = (overrideVram != null && Number.isFinite(overrideVram) && overrideVram > 0)
+        ? overrideVram : gpuDetails.vram;
+    const isApple = gpuDetails.platform === 'darwin' || cpuDetails.architecture === 'Apple Silicon';
+    const isUnified = gpuDetails.unified || isApple;
+    const platform = isApple ? 'darwin' : 'linux';
+    const backend = gpuDetails.backend;
+
+    const effectiveMemory = isUnified
+        ? totalRAM
+        : (vram > 0 ? vram : Math.round(totalRAM * 0.7));
+
+    const gpuSpecs = gpuDetails.model ? specs.getGPUScore(gpuDetails.model) : { score: 0 };
+    const cpuScore = specs.getCPUScore(cpuDetails.brand);
+    const freeRAM = Math.round(totalRAM * 0.6);
+    const usedRAM = totalRAM - freeRAM;
+
+    const displayParts = [];
+    if (cpuDetails.brand && cpuDetails.brand !== 'Unknown CPU') displayParts.push(cpuDetails.brand);
+    displayParts.push(`${totalRAM}GB RAM`);
+    if (gpuDetails.model) displayParts.push(gpuDetails.model);
+    const displayName = `Custom: ${displayParts.join(' + ')}`;
+
+    const hardware = {
+        cpu: {
+            brand: cpuDetails.brand,
+            manufacturer: cpuDetails.manufacturer,
+            family: 'Unknown',
+            model: 'Unknown',
+            speed: cpuDetails.speed,
+            speedMax: cpuDetails.speed,
+            cores: cpuDetails.cores,
+            physicalCores: cpuDetails.physicalCores,
+            processors: 1,
+            cache: { l1d: 0, l1i: 0, l2: 0, l3: 0 },
+            architecture: cpuDetails.architecture,
+            score: cpuScore.score || 70
+        },
+        memory: {
+            total: totalRAM,
+            free: freeRAM,
+            used: usedRAM,
+            available: freeRAM,
+            usagePercent: Math.round((usedRAM / totalRAM) * 100),
+            swapTotal: 0,
+            swapUsed: 0,
+            score: totalRAM >= 64 ? 55 : (totalRAM >= 32 ? 50 : (totalRAM >= 16 ? 40 : 25))
+        },
+        gpu: {
+            model: gpuDetails.model || 'No GPU detected',
+            vendor: gpuDetails.vendor || 'Unknown',
+            vram: vram,
+            vramPerGPU: vram,
+            vramDynamic: false,
+            dedicated: gpuDetails.dedicated,
+            driverVersion: 'Simulated',
+            gpuCount: 1,
+            isMultiGPU: false,
+            all: gpuDetails.model ? [{
+                model: gpuDetails.model,
+                vram: vram,
+                vendor: gpuDetails.vendor
+            }] : [],
+            displays: 1,
+            score: gpuSpecs.score || 0,
+            unified: isUnified,
+            backend: backend
+        },
+        system: {
+            manufacturer: isApple ? 'Apple' : 'Simulated System',
+            model: displayName,
+            version: 'Simulated'
+        },
+        os: {
+            platform: platform,
+            distro: isApple ? 'macOS' : 'Linux',
+            release: 'Simulated',
+            codename: 'Simulated',
+            kernel: 'Simulated',
+            arch: cpuDetails.architecture === 'Apple Silicon' ? 'arm64' : 'x64',
+            hostname: 'simulated-host',
+            logofile: ''
+        },
+        timestamp: Date.now(),
+        summary: {
+            bestBackend: backend,
+            gpuModel: gpuDetails.model,
+            effectiveMemory: effectiveMemory,
+            systemRAM: totalRAM,
+            totalVRAM: vram
+        },
+        _displayName: displayName
+    };
+
+    hardware.cpu.capabilities = {};
+    if (cpuDetails.architecture === 'Apple Silicon') {
+        hardware.cpu.capabilities.neon = true;
+    } else {
+        hardware.cpu.capabilities.avx2 = true;
+    }
+
+    return hardware;
+}
+
+function getProfile(key) {
+    return HARDWARE_PROFILES[key] || null;
+}
+
+function getProfileKeys() {
+    return Object.keys(HARDWARE_PROFILES);
+}
+
+function getProfilesByCategory() {
+    const grouped = {};
+    for (const [key, profile] of Object.entries(HARDWARE_PROFILES)) {
+        const cat = profile.category;
+        if (!grouped[cat]) grouped[cat] = {};
+        grouped[cat][key] = profile;
+    }
+    return grouped;
+}
+
+function listProfiles() {
+    const lines = [];
+    const grouped = getProfilesByCategory();
+
+    for (const [category, profiles] of Object.entries(grouped)) {
+        const label = CATEGORY_LABELS[category] || category;
+        lines.push(`\n  ${label}:`);
+        for (const [key, profile] of Object.entries(profiles)) {
+            const vramLabel = profile.gpu.unified
+                ? `${profile.memory.total}GB unified`
+                : (profile.gpu.vram > 0 ? `${profile.gpu.vram}GB VRAM` : 'No GPU');
+            const ramLabel = profile.gpu.unified ? '' : `, ${profile.memory.total}GB RAM`;
+            lines.push(`    ${key.padEnd(14)} ${profile.displayName.padEnd(38)} ${vramLabel}${ramLabel}`);
+        }
+    }
+
+    return lines;
+}
+
+module.exports = {
+    HARDWARE_PROFILES,
+    buildFullHardwareObject,
+    buildCustomHardwareObject,
+    getProfile,
+    getProfileKeys,
+    getProfilesByCategory,
+    listProfiles,
+    CATEGORY_LABELS
+};

package/src/index.js

@@ -32,6 +32,21 @@ class LLMChecker {
         this.logger = getLogger().createChild('LLMChecker');
         this.verbose = options.verbose !== false; // Default to verbose unless explicitly disabled
         this.progress = null; // Will be initialized when needed
+        this._isSimulated = false;
+    }
+
+    setSimulatedHardware(hardwareObject) {
+        this.hardwareDetector.setSimulatedHardware(hardwareObject);
+        this._isSimulated = true;
+    }
+
+    clearSimulatedHardware() {
+        this.hardwareDetector.clearSimulatedHardware();
+        this._isSimulated = false;
+    }
+
+    get isSimulated() {
+        return this._isSimulated;
     }
 
     async analyze(options = {}) {
@@ -47,7 +62,10 @@ class LLMChecker {
 
             // Step 1: Hardware Detection
             if (this.progress) {
-                this.progress.step('System Detection', 'Scanning hardware specifications...');
+                const detectionLabel = this._isSimulated
+                    ? 'Using simulated hardware profile...'
+                    : 'Scanning hardware specifications...';
+                this.progress.step('System Detection', detectionLabel);
             }
             
             const hardware = await this.hardwareDetector.getSystemInfo();

package/src/ui/cli-theme.js

@@ -48,7 +48,9 @@ const MASCOT_MASK = [
 
 const DEFAULT_LOOP = true;
 const FRAMES_PER_SECOND = 14;
-const DEFAULT_BANNER_SOURCE = path.join(os.homedir(), 'Downloads', 'ascii-motion-cli.tsx');
+// Security: do not auto-load executable-style banner sources from user-writable folders.
+// External banner loading is opt-in via LLM_CHECKER_BANNER_SOURCE and supports JSON only.
+const DEFAULT_BANNER_SOURCE = null;
 const DEFAULT_TEXT_BANNER_SOURCE = path.join(
     os.homedir(),
     'Desktop',
@@ -74,80 +76,28 @@ function fitLine(line, width) {
     return `${value.slice(0, width - 3)}...`;
 }
 
-function extractBalanced(source, startIndex, openChar, closeChar) {
-    if (startIndex < 0 || source[startIndex] !== openChar) return null;
-
-    let depth = 0;
-    let inString = null;
-    let escape = false;
-
-    for (let index = startIndex; index < source.length; index += 1) {
-        const char = source[index];
-
-        if (inString) {
-            if (escape) {
-                escape = false;
-                continue;
-            }
-
-            if (char === '\\') {
-                escape = true;
-                continue;
-            }
-
-            if (char === inString) {
-                inString = null;
-            }
-
-            continue;
-        }
-
-        if (char === '"' || char === '\'' || char === '`') {
-            inString = char;
-            continue;
-        }
-
-        if (char === openChar) {
-            depth += 1;
-        } else if (char === closeChar) {
-            depth -= 1;
-            if (depth === 0) {
-                return source.slice(startIndex, index + 1);
-            }
-        }
-    }
-
-    return null;
+function isPlainObject(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
 }
 
-function extractAssignedLiteral(source, constName, openChar, closeChar) {
-    const marker = `const ${constName}`;
-    const markerIndex = source.indexOf(marker);
-    if (markerIndex < 0) return null;
-
-    const equalsIndex = source.indexOf('=', markerIndex);
-    if (equalsIndex < 0) return null;
-
-    const startIndex = source.indexOf(openChar, equalsIndex);
-    if (startIndex < 0) return null;
-
-    return extractBalanced(source, startIndex, openChar, closeChar);
-}
-
-function evaluateLiteral(literal) {
-    if (!literal) return null;
+function parseExternalBannerPayload(source) {
+    let parsed = null;
     try {
-        return Function(`"use strict"; return (${literal});`)();
+        parsed = JSON.parse(source);
     } catch {
         return null;
     }
-}
 
-function parseNumericConstant(source, constName) {
-    const match = source.match(new RegExp(`const\\s+${constName}\\s*=\\s*(\\d+(?:\\.\\d+)?)`));
-    if (!match) return null;
-    const parsed = Number.parseFloat(match[1]);
-    return Number.isFinite(parsed) ? parsed : null;
+    if (!isPlainObject(parsed)) return null;
+    const frames = Array.isArray(parsed.frames) ? parsed.frames : null;
+    if (!frames || frames.length === 0) return null;
+
+    return {
+        frames,
+        themeDark: isPlainObject(parsed.themeDark) ? parsed.themeDark : {},
+        themeLight: isPlainObject(parsed.themeLight) ? parsed.themeLight : {},
+        canvasWidth: Number.isFinite(parsed.canvasWidth) ? parsed.canvasWidth : null
+    };
 }
 
 function getLongestFrameLine(frames) {
@@ -176,6 +126,18 @@ function normalizeExternalFrame(frame, contentWidth, defaultDuration) {
 
 function loadExternalBanner(sourceFile) {
     const filePath = sourceFile || process.env.LLM_CHECKER_BANNER_SOURCE || DEFAULT_BANNER_SOURCE;
+    if (!filePath) return null;
+
+    const extension = path.extname(filePath).toLowerCase();
+    if (extension !== '.json') {
+        cachedExternalBanner = {
+            filePath,
+            mtimeMs: -1,
+            payload: null
+        };
+        return null;
+    }
+
     let mtimeMs = -1;
 
     try {
@@ -200,16 +162,8 @@ function loadExternalBanner(sourceFile) {
 
     try {
         const source = fs.readFileSync(filePath, 'utf8');
-        const framesLiteral = extractAssignedLiteral(source, 'FRAMES', '[', ']');
-        const darkThemeLiteral = extractAssignedLiteral(source, 'THEME_DARK', '{', '}');
-        const lightThemeLiteral = extractAssignedLiteral(source, 'THEME_LIGHT', '{', '}');
-
-        const frames = evaluateLiteral(framesLiteral);
-        const themeDark = evaluateLiteral(darkThemeLiteral);
-        const themeLight = evaluateLiteral(lightThemeLiteral);
-        const canvasWidth = parseNumericConstant(source, 'CANVAS_WIDTH');
-
-        if (!Array.isArray(frames) || frames.length === 0) {
+        const payload = parseExternalBannerPayload(source);
+        if (!payload) {
             cachedExternalBanner = {
                 filePath,
                 mtimeMs,
@@ -218,13 +172,6 @@ function loadExternalBanner(sourceFile) {
             return null;
         }
 
-        const payload = {
-            frames,
-            themeDark: themeDark && typeof themeDark === 'object' ? themeDark : {},
-            themeLight: themeLight && typeof themeLight === 'object' ? themeLight : {},
-            canvasWidth: Number.isFinite(canvasWidth) ? canvasWidth : null
-        };
-
         cachedExternalBanner = {
             filePath,
             mtimeMs,

package/src/ui/interactive-panel.js

@@ -11,6 +11,7 @@ const PRIMARY_COMMAND_PRIORITY = [
     'help',
     'mcp-setup',
     'recommend',
+    'simulate',
     'ai-run',
     'ollama-plan',
     'list-models',

package/src/data/CLAUDE.md

@@ -1,17 +0,0 @@
-<claude-mem-context>
-# Recent Activity
-
-<!-- This section is auto-generated by claude-mem. Edit content outside the tags. -->
-
-### Feb 12, 2026
-
-| ID | Time | T | Title | Read |
-|----|------|---|-------|------|
-| #3464 | 10:03 PM | 🔵 | SQL Database Schema - Indexed Model Repository with Benchmarks | ~555 |
-
-### Feb 14, 2026
-
-| ID | Time | T | Title | Read |
-|----|------|---|-------|------|
-| #4339 | 6:49 PM | 🟣 | MCP server implementation and documentation added to llm-checker repository | ~457 |
-</claude-mem-context>

package/src/hardware/CLAUDE.md

@@ -1,18 +0,0 @@
-<claude-mem-context>
-# Recent Activity
-
-<!-- This section is auto-generated by claude-mem. Edit content outside the tags. -->
-
-### Feb 12, 2026
-
-| ID | Time | T | Title | Read |
-|----|------|---|-------|------|
-| #3490 | 10:24 PM | 🔵 | Hardware Detector Cache Implementation - 5-Minute TTL Without Force Refresh Option | ~536 |
-| #3440 | 9:58 PM | 🔵 | Hardware Detection System - Multi-GPU Support with Intelligent Selection | ~611 |
-
-### Feb 14, 2026
-
-| ID | Time | T | Title | Read |
-|----|------|---|-------|------|
-| #4339 | 6:49 PM | 🟣 | MCP server implementation and documentation added to llm-checker repository | ~457 |
-</claude-mem-context>

package/src/hardware/backends/CLAUDE.md

@@ -1,17 +0,0 @@
-<claude-mem-context>
-# Recent Activity
-
-<!-- This section is auto-generated by claude-mem. Edit content outside the tags. -->
-
-### Feb 12, 2026
-
-| ID | Time | T | Title | Read |
-|----|------|---|-------|------|
-| #3453 | 10:01 PM | 🔵 | CUDA Detector Implementation - NVIDIA GPU Detection via nvidia-smi | ~497 |
-
-### Feb 14, 2026
-
-| ID | Time | T | Title | Read |
-|----|------|---|-------|------|
-| #4339 | 6:49 PM | 🟣 | MCP server implementation and documentation added to llm-checker repository | ~457 |
-</claude-mem-context>

package/src/models/CLAUDE.md

@@ -1,23 +0,0 @@
-<claude-mem-context>
-# Recent Activity
-
-<!-- This section is auto-generated by claude-mem. Edit content outside the tags. -->
-
-### Feb 12, 2026
-
-| ID | Time | T | Title | Read |
-|----|------|---|-------|------|
-| #3442 | 9:59 PM | 🔵 | Static Model Database Structure - Hardcoded LLM Specifications | ~572 |
-
-### Feb 13, 2026
-
-| ID | Time | T | Title | Read |
-|----|------|---|-------|------|
-| #3699 | 12:05 AM | ✅ | Git Push Consolidated Architecture Changes to GitHub | ~367 |
-
-### Feb 14, 2026
-
-| ID | Time | T | Title | Read |
-|----|------|---|-------|------|
-| #4339 | 6:49 PM | 🟣 | MCP server implementation and documentation added to llm-checker repository | ~457 |
-</claude-mem-context>

package/src/ollama/CLAUDE.md

@@ -1,30 +0,0 @@
-<claude-mem-context>
-# Recent Activity
-
-<!-- This section is auto-generated by claude-mem. Edit content outside the tags. -->
-
-### Feb 12, 2026
-
-| ID | Time | T | Title | Read |
-|----|------|---|-------|------|
-| #3500 | 10:26 PM | 🔴 | pullModel() Stream Handling Improved - Success Validation Added | ~458 |
-| #3499 | " | 🔴 | Race Condition Fixed in Ollama Availability Cache | ~440 |
-| #3498 | 10:25 PM | 🔵 | testModelPerformance() Timeout Already Fixed | ~418 |
-| #3497 | " | 🔴 | Timeout Fixed in deleteModel() Using AbortController | ~391 |
-| #3496 | " | 🔴 | Timeout Fixed in testConnection() Using AbortController | ~395 |
-| #3495 | " | 🔴 | Fixed unbounded memory growth in native scraper HTTP request handler | ~361 |
-| #3493 | " | 🔴 | Fixed race condition in checkOllamaAvailability() with promise deduplication | ~398 |
-| #3491 | 10:24 PM | 🔴 | Added missing clearTimeout() in testModelPerformance() | ~319 |
-| #3489 | " | 🔴 | Fixed node-fetch timeout handling in testModelPerformance() | ~332 |
-| #3488 | " | 🔴 | Fixed node-fetch timeout handling in testConnection() tags check | ~303 |
-| #3486 | " | 🔴 | Fixed node-fetch timeout handling in getRunningModels() | ~308 |
-| #3484 | 10:23 PM | 🔵 | Ollama Client Timeout Implementation - Mixed Patterns with AbortController | ~554 |
-| #3443 | 9:59 PM | 🔵 | Ollama Native Scraper - Web Scraping with Dual Cache Strategy | ~594 |
-| #3437 | 9:58 PM | 🔵 | Ollama Client Implementation - HTTP API Wrapper with Connection Management | ~605 |
-
-### Feb 14, 2026
-
-| ID | Time | T | Title | Read |
-|----|------|---|-------|------|
-| #4339 | 6:49 PM | 🟣 | MCP server implementation and documentation added to llm-checker repository | ~457 |
-</claude-mem-context>

package/src/plugins/CLAUDE.md

@@ -1,17 +0,0 @@
-<claude-mem-context>
-# Recent Activity
-
-<!-- This section is auto-generated by claude-mem. Edit content outside the tags. -->
-
-### Feb 12, 2026
-
-| ID | Time | T | Title | Read |
-|----|------|---|-------|------|
-| #3462 | 10:02 PM | 🔵 | Plugin System Architecture - Hook-Based Extensibility Framework | ~648 |
-
-### Feb 14, 2026
-
-| ID | Time | T | Title | Read |
-|----|------|---|-------|------|
-| #4339 | 6:49 PM | 🟣 | MCP server implementation and documentation added to llm-checker repository | ~457 |
-</claude-mem-context>

package/src/utils/CLAUDE.md

@@ -1,17 +0,0 @@
-<claude-mem-context>
-# Recent Activity
-
-<!-- This section is auto-generated by claude-mem. Edit content outside the tags. -->
-
-### Feb 12, 2026
-
-| ID | Time | T | Title | Read |
-|----|------|---|-------|------|
-| #3438 | 9:58 PM | 🔵 | Configuration Management System - Comprehensive Settings with Environment Overrides | ~580 |
-
-### Feb 14, 2026
-
-| ID | Time | T | Title | Read |
-|----|------|---|-------|------|
-| #4339 | 6:49 PM | 🟣 | MCP server implementation and documentation added to llm-checker repository | ~457 |
-</claude-mem-context>