llm-checker 3.2.0 → 3.2.2

package/bin/enhanced_cli.js

@@ -16,6 +16,28 @@ function getLLMChecker() {
 const { getLogger } = require('../src/utils/logger');
 const fs = require('fs');
 const path = require('path');
+const {
+    SUPPORTED_RUNTIMES,
+    normalizeRuntime,
+    runtimeSupportedOnHardware,
+    getRuntimeDisplayName,
+    getRuntimeCommandSet
+} = require('../src/runtime/runtime-support');
+const SpeculativeDecodingEstimator = require('../src/models/speculative-decoding-estimator');
+const PolicyManager = require('../src/policy/policy-manager');
+const PolicyEngine = require('../src/policy/policy-engine');
+const {
+    collectCandidatesFromAnalysis,
+    collectCandidatesFromRecommendationData,
+    buildPolicyRuntimeContext,
+    evaluatePolicyCandidates,
+    resolvePolicyEnforcement
+} = require('../src/policy/cli-policy');
+const {
+    buildComplianceReport,
+    serializeComplianceReport
+} = require('../src/policy/audit-reporter');
+const policyManager = new PolicyManager();
 
 // ASCII Art for each command - Large text banners
 const ASCII_ART = {
@@ -1406,10 +1428,18 @@ function displaySimplifiedSystemInfo(hardware) {
     console.log(`Hardware Tier: ${tierColor.bold(tier)}`);
 }
 
-async function displayModelRecommendations(analysis, hardware, useCase = 'general', limit = 1) {
+async function displayModelRecommendations(analysis, hardware, useCase = 'general', limit = 1, runtime = 'ollama') {
     const title = limit === 1 ? 'RECOMMENDED MODEL' : `TOP ${limit} COMPATIBLE MODELS`;
     console.log(chalk.green.bold(`\n${title}`));
     console.log(chalk.gray('─'.repeat(50)));
+
+    const selectedRuntime = normalizeRuntime(runtime);
+    const runtimeLabel = getRuntimeDisplayName(selectedRuntime);
+    const speculativeEstimator = new SpeculativeDecodingEstimator();
+    const speculativeCandidatePool = [
+        ...(analysis?.compatible || []),
+        ...(analysis?.marginal || [])
+    ];
     
     // Find the best models from compatible models considering use case
     let selectedModels = [];
@@ -1760,42 +1790,75 @@ async function displayModelRecommendations(analysis, hardware, useCase = 'genera
             if (model.performanceEstimate) {
                 console.log(`Estimated Speed: ${chalk.yellow(model.performanceEstimate.estimatedTokensPerSecond || 'N/A')} tokens/sec`);
             }
-            
-            // Check if it's already installed by comparing with Ollama integration
+
+            console.log(`Runtime: ${chalk.white(runtimeLabel)}`);
+            const runtimeCommands = getRuntimeCommandSet(model, selectedRuntime);
+
+            // Check installation only when using Ollama runtime.
             let isInstalled = false;
-            try {
-                isInstalled = await checkIfModelInstalled(model, analysis.ollamaInfo);
-                if (isInstalled) {
-                    console.log(`Status: ${chalk.green('Already installed in Ollama')}`);
-                } else if (analysis.ollamaInfo && analysis.ollamaInfo.available) {
-                    console.log(`Status: ${chalk.gray('Available for installation')}`);
-                } else {
-                    console.log(`Status: ${chalk.yellow('Requires Ollama (not detected)')}`);
+            if (selectedRuntime === 'ollama') {
+                try {
+                    isInstalled = await checkIfModelInstalled(model, analysis.ollamaInfo);
+                    if (isInstalled) {
+                        console.log(`Status: ${chalk.green('Already installed in Ollama')}`);
+                    } else if (analysis.ollamaInfo && analysis.ollamaInfo.available) {
+                        console.log(`Status: ${chalk.gray('Available for installation')}`);
+                    } else {
+                        console.log(`Status: ${chalk.yellow('Requires Ollama (not detected)')}`);
+                    }
+                } catch (installCheckError) {
+                    if (analysis.ollamaInfo && analysis.ollamaInfo.available) {
+                        console.log(`Status: ${chalk.gray('Available for installation')}`);
+                    } else {
+                        console.log(`Status: ${chalk.yellow('Requires Ollama (not detected)')}`);
+                    }
                 }
-            } catch (installCheckError) {
-                // If checking installation status fails, show based on Ollama availability
-                if (analysis.ollamaInfo && analysis.ollamaInfo.available) {
-                    console.log(`Status: ${chalk.gray('Available for installation')}`);
-                } else {
-                    console.log(`Status: ${chalk.yellow('Requires Ollama (not detected)')}`);
+
+                const ollamaCommand = getOllamaInstallCommand(model);
+                if (ollamaCommand) {
+                    const modelName = extractModelName(ollamaCommand);
+                    if (isInstalled) {
+                        console.log(`\nRun: ${chalk.cyan.bold(`ollama run ${modelName}`)}`);
+                    } else {
+                        console.log(`\nPull: ${chalk.cyan.bold(ollamaCommand)}`);
+                    }
+                } else if (model.ollamaTag || model.ollamaId) {
+                    const tag = model.ollamaTag || model.ollamaId;
+                    if (isInstalled) {
+                        console.log(`\nRun: ${chalk.cyan.bold(`ollama run ${tag}`)}`);
+                    } else {
+                        console.log(`\nPull: ${chalk.cyan.bold(`ollama pull ${tag}`)}`);
+                    }
+                }
+            } else {
+                console.log(`Status: ${chalk.gray(`${runtimeLabel} runtime selected`)}`);
+                console.log(`\nRun: ${chalk.cyan.bold(runtimeCommands.run)}`);
+                if (index === 0) {
+                    console.log(`Install runtime: ${chalk.cyan.bold(runtimeCommands.install)}`);
+                    console.log(`Fetch model: ${chalk.cyan.bold(runtimeCommands.pull)}`);
                 }
             }
 
-            // Show pull/run command directly in each model block (Issue #3)
-            const ollamaCommand = getOllamaInstallCommand(model);
-            if (ollamaCommand) {
-                const modelName = extractModelName(ollamaCommand);
-                if (isInstalled) {
-                    console.log(`\nCommand: ${chalk.cyan.bold(`ollama run ${modelName}`)}`);
-                } else {
-                    console.log(`\nCommand: ${chalk.cyan.bold(ollamaCommand)}`);
-                }
-            } else if (model.ollamaTag || model.ollamaId) {
-                const tag = model.ollamaTag || model.ollamaId;
-                if (isInstalled) {
-                    console.log(`\nCommand: ${chalk.cyan.bold(`ollama run ${tag}`)}`);
-                } else {
-                    console.log(`\nCommand: ${chalk.cyan.bold(`ollama pull ${tag}`)}`);
+            const speculativeInfo =
+                model.speculativeDecoding ||
+                speculativeEstimator.estimate({
+                    model,
+                    candidates: speculativeCandidatePool,
+                    hardware,
+                    runtime: selectedRuntime
+                });
+
+            if (speculativeInfo && speculativeInfo.runtime === selectedRuntime) {
+                if (speculativeInfo.enabled) {
+                    console.log(
+                        `SpecDec: ${chalk.green(`+${speculativeInfo.estimatedThroughputGainPct}%`)} ` +
+                        `(${chalk.gray(`draft: ${speculativeInfo.draftModel}`)})`
+                    );
+                } else if (speculativeInfo.estimatedSpeedup) {
+                    const suggested = speculativeInfo.suggestedDraftModel ? ` with ${speculativeInfo.suggestedDraftModel}` : '';
+                    console.log(
+                        `SpecDec estimate: ${chalk.yellow(`+${speculativeInfo.estimatedThroughputGainPct}%`)}${chalk.gray(suggested)}`
+                    );
                 }
             }
         }
@@ -1807,9 +1870,12 @@ async function displayModelRecommendations(analysis, hardware, useCase = 'genera
     return selectedModels;
 }
 
-async function displayQuickStartCommands(analysis, recommendedModel = null, allRecommended = null) {
+async function displayQuickStartCommands(analysis, recommendedModel = null, allRecommended = null, runtime = 'ollama') {
     console.log(chalk.yellow.bold('\nQUICK START'));
     console.log(chalk.gray('─'.repeat(50)));
+
+    const selectedRuntime = normalizeRuntime(runtime);
+    const runtimeLabel = getRuntimeDisplayName(selectedRuntime);
     
     // Use the first model from allRecommended if available, otherwise fallback to recommendedModel
     let bestModel = (allRecommended && allRecommended.length > 0) ? allRecommended[0] : recommendedModel;
@@ -1824,6 +1890,33 @@ async function displayQuickStartCommands(analysis, recommendedModel = null, allR
         }
     }
     
+    if (selectedRuntime !== 'ollama') {
+        if (!bestModel) {
+            console.log(`1. Try expanding search: ${chalk.cyan('llm-checker check --include-cloud')}`);
+            return;
+        }
+
+        const runtimeCommands = getRuntimeCommandSet(bestModel, selectedRuntime);
+        console.log(`1. Install ${runtimeLabel}:`);
+        console.log(`   ${chalk.cyan.bold(runtimeCommands.install)}`);
+        console.log(`2. Fetch model weights:`);
+        console.log(`   ${chalk.cyan.bold(runtimeCommands.pull)}`);
+        console.log(`3. Run model:`);
+        console.log(`   ${chalk.cyan.bold(runtimeCommands.run)}`);
+
+        const speculative = bestModel.speculativeDecoding;
+        if (speculative && speculative.enabled) {
+            console.log(`4. SpecDec suggestion (${chalk.green(`+${speculative.estimatedThroughputGainPct}%`)}):`);
+            if (selectedRuntime === 'vllm') {
+                console.log(`   ${chalk.cyan.bold(`${runtimeCommands.run} --speculative-model '${speculative.draftModelRef || speculative.draftModel}'`)}`);
+            } else if (selectedRuntime === 'mlx') {
+                console.log(`   ${chalk.gray(`Use draft model ${speculative.draftModelRef || speculative.draftModel} when enabling speculative decoding in MLX-LM`)}`);
+            }
+        }
+
+        return;
+    }
+
     if (analysis.ollamaInfo && !analysis.ollamaInfo.available) {
         console.log(`1. Install Ollama: ${chalk.underline('https://ollama.ai')}`);
         console.log(`2. Come back and run this command again`);
@@ -1981,6 +2074,365 @@ function extractModelName(command) {
     return match ? match[1] : 'model';
 }
 
+function loadPolicyConfiguration(policyFile) {
+    const validation = policyManager.validatePolicyFile(policyFile);
+    if (!validation.valid) {
+        const details = validation.errors
+            .map((entry) => `${entry.path}: ${entry.message}`)
+            .join('; ');
+        throw new Error(`Invalid policy file: ${details}`);
+    }
+
+    return {
+        policyPath: validation.path,
+        policy: validation.policy,
+        policyEngine: new PolicyEngine(validation.policy)
+    };
+}
+
+function parseSizeFilterInput(sizeStr) {
+    if (!sizeStr) return null;
+    const match = String(sizeStr)
+        .toUpperCase()
+        .trim()
+        .match(/^([0-9]+(?:\.[0-9]+)?)\s*(B|GB)?$/);
+    if (!match) return null;
+
+    const value = Number.parseFloat(match[1]);
+    const unit = match[2] || 'B';
+
+    // Convert to "B params" approximation used by existing check flow
+    return unit === 'GB' ? value / 0.5 : value;
+}
+
+function normalizeUseCaseInput(useCase = '') {
+    const alias = String(useCase || '')
+        .toLowerCase()
+        .trim();
+
+    const useCaseMap = {
+        embed: 'embeddings',
+        embedding: 'embeddings',
+        embeddings: 'embeddings',
+        embedings: 'embeddings',
+        talk: 'chat',
+        talking: 'chat',
+        conversation: 'chat',
+        chat: 'chat'
+    };
+
+    return useCaseMap[alias] || alias || 'general';
+}
+
+function resolveAuditFormats(formatOption, policy) {
+    const requested = String(formatOption || 'json').trim().toLowerCase();
+    const allowed = new Set(['json', 'csv', 'sarif']);
+
+    if (requested === 'all') {
+        const configured = Array.isArray(policy?.reporting?.formats)
+            ? policy.reporting.formats
+                  .map((entry) => String(entry || '').trim().toLowerCase())
+                  .filter((entry) => allowed.has(entry))
+            : [];
+
+        return configured.length > 0 ? configured : ['json', 'csv', 'sarif'];
+    }
+
+    if (!allowed.has(requested)) {
+        throw new Error('Invalid format. Use one of: json, csv, sarif, all');
+    }
+
+    return [requested];
+}
+
+function toAuditOutputPath({ outputPath, outputDir, commandName, format, timestamp }) {
+    if (outputPath) {
+        return path.resolve(outputPath);
+    }
+
+    const safeTimestamp = timestamp.replace(/[:.]/g, '-');
+    const extension = format === 'sarif' ? 'sarif.json' : format;
+    const fileName = `${commandName}-policy-audit-${safeTimestamp}.${extension}`;
+    return path.resolve(outputDir || 'audit-reports', fileName);
+}
+
+function writeReportFile(filePath, content) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, content, 'utf8');
+}
+
+function displayPolicySummary(commandName, policyConfig, evaluation, enforcement) {
+    if (!policyConfig || !evaluation || !enforcement) return;
+
+    console.log('\n' + chalk.bgMagenta.white.bold(` POLICY SUMMARY (${commandName.toUpperCase()}) `));
+    console.log(chalk.magenta('╭' + '─'.repeat(65)));
+    console.log(chalk.magenta('│') + ` File: ${chalk.white(policyConfig.policyPath)}`);
+    console.log(
+        chalk.magenta('│') +
+            ` Mode: ${chalk.cyan(enforcement.mode)} | Action: ${chalk.cyan(enforcement.onViolation)}`
+    );
+    console.log(chalk.magenta('│') + ` Total checked: ${chalk.white.bold(evaluation.totalChecked)}`);
+    console.log(chalk.magenta('│') + ` Pass: ${chalk.green.bold(evaluation.passCount)} | Fail: ${chalk.red.bold(evaluation.failCount)}`);
+    console.log(
+        chalk.magenta('│') +
+            ` Suppressed: ${chalk.yellow.bold(evaluation.suppressedViolationCount || 0)} | Exceptions: ${chalk.cyan.bold(
+                evaluation.exceptionsAppliedCount || 0
+            )}`
+    );
+
+    if (evaluation.topViolations.length === 0) {
+        console.log(chalk.magenta('│') + ` Top violations: ${chalk.green('none')}`);
+    } else {
+        console.log(chalk.magenta('│') + ` Top violations:`);
+        evaluation.topViolations.slice(0, 3).forEach((violation) => {
+            console.log(
+                chalk.magenta('│') +
+                    `   - ${chalk.yellow(violation.code)}: ${chalk.white(violation.count)}`
+            );
+        });
+    }
+
+    if (enforcement.shouldBlock) {
+        console.log(
+            chalk.magenta('│') +
+                chalk.red.bold(
+                    ` Enforcement result: blocking violations detected (exit ${enforcement.exitCode})`
+                )
+        );
+    } else if (enforcement.mode === 'audit' && enforcement.hasFailures) {
+        console.log(
+            chalk.magenta('│') +
+                chalk.yellow(' Audit mode: violations reported, command exits with code 0')
+        );
+    } else if (enforcement.onViolation === 'warn' && enforcement.hasFailures) {
+        console.log(
+            chalk.magenta('│') +
+                chalk.yellow(' Enforce+warn: violations reported, command exits with code 0')
+        );
+    } else {
+        console.log(chalk.magenta('│') + chalk.green(' Policy check passed'));
+    }
+
+    console.log(chalk.magenta('╰' + '─'.repeat(65)));
+}
+
+const policyCommand = program
+    .command('policy')
+    .description('Manage enterprise policy files (policy.yaml)')
+    .showHelpAfterError();
+
+policyCommand
+    .command('init')
+    .description('Create a policy.yaml template')
+    .option('-f, --file <path>', 'Policy file path', 'policy.yaml')
+    .option('--force', 'Overwrite existing file if it already exists')
+    .action((options) => {
+        try {
+            const result = policyManager.initPolicy(options.file, {
+                force: Boolean(options.force)
+            });
+
+            const status = result.overwritten ? 'overwritten' : 'created';
+            console.log(chalk.green(`Policy file ${status}: ${result.path}`));
+        } catch (error) {
+            console.error(chalk.red(`Failed to initialize policy: ${error.message}`));
+            process.exit(1);
+        }
+    });
+
+policyCommand
+    .command('validate')
+    .description('Validate policy.yaml against the v1 schema')
+    .option('-f, --file <path>', 'Policy file path', 'policy.yaml')
+    .option('-j, --json', 'Output validation result as JSON')
+    .action((options) => {
+        try {
+            const result = policyManager.validatePolicyFile(options.file);
+
+            if (options.json) {
+                console.log(JSON.stringify({
+                    valid: result.valid,
+                    file: result.path,
+                    errorCount: result.errors.length,
+                    errors: result.errors
+                }, null, 2));
+                if (!result.valid) {
+                    process.exit(1);
+                }
+            } else if (result.valid) {
+                const mode = result.policy?.mode || 'unknown';
+                console.log(chalk.green(`Policy is valid (${mode} mode): ${result.path}`));
+            } else {
+                console.error(chalk.red(`Policy validation failed: ${result.path}`));
+                result.errors.forEach((entry) => {
+                    console.error(chalk.red(`  - ${entry.path}: ${entry.message}`));
+                });
+                process.exit(1);
+            }
+        } catch (error) {
+            if (options.json) {
+                console.log(JSON.stringify({
+                    valid: false,
+                    file: policyManager.resolvePolicyPath(options.file),
+                    errorCount: 1,
+                    errors: [{ path: 'file', message: error.message }]
+                }, null, 2));
+            } else {
+                console.error(chalk.red(`Policy validation failed: ${error.message}`));
+            }
+            process.exit(1);
+        }
+    });
+
+policyCommand.action(() => {
+    policyCommand.outputHelp();
+});
+
+const auditCommand = program
+    .command('audit')
+    .description('Run policy audits and export compliance reports')
+    .showHelpAfterError();
+
+auditCommand
+    .command('export')
+    .description('Evaluate policy compliance and export JSON/CSV/SARIF reports')
+    .requiredOption('--policy <file>', 'Policy file path')
+    .option('--command <name>', 'Evaluation source: check | recommend', 'check')
+    .option('--format <format>', 'Report format: json | csv | sarif | all', 'json')
+    .option('--out <path>', 'Output file path (single-format export only)')
+    .option('--out-dir <path>', 'Output directory when --out is omitted', 'audit-reports')
+    .option('-u, --use-case <case>', 'Use case when --command check is selected', 'general')
+    .option('-c, --category <category>', 'Category hint when --command recommend is selected')
+    .option('--runtime <runtime>', `Runtime for check mode (${SUPPORTED_RUNTIMES.join('|')})`, 'ollama')
+    .option('--include-cloud', 'Include cloud models in check-mode analysis')
+    .option('--max-size <size>', 'Maximum model size for check mode (e.g., "24B" or "12GB")')
+    .option('--min-size <size>', 'Minimum model size for check mode (e.g., "3B" or "2GB")')
+    .option('-l, --limit <number>', 'Model analysis limit for check mode', '25')
+    .option('--no-verbose', 'Disable verbose progress while collecting audit inputs')
+    .action(async (options) => {
+        try {
+            const policyConfig = loadPolicyConfiguration(options.policy);
+            const selectedCommand = String(options.command || 'check')
+                .toLowerCase()
+                .trim();
+
+            if (!['check', 'recommend'].includes(selectedCommand)) {
+                throw new Error('Invalid --command value. Use "check" or "recommend".');
+            }
+
+            const exportFormats = resolveAuditFormats(options.format, policyConfig.policy);
+            if (options.out && exportFormats.length > 1) {
+                throw new Error('--out can only be used with a single export format.');
+            }
+
+            const verboseEnabled = options.verbose !== false;
+            const checker = new (getLLMChecker())({ verbose: verboseEnabled });
+            const hardware = await checker.getSystemInfo();
+
+            let runtimeBackend = 'ollama';
+            let policyCandidates = [];
+            let analysisResult = null;
+            let recommendationResult = null;
+
+            if (selectedCommand === 'check') {
+                let selectedRuntime = normalizeRuntime(options.runtime);
+                if (!runtimeSupportedOnHardware(selectedRuntime, hardware)) {
+                    selectedRuntime = 'ollama';
+                }
+
+                const maxSize = parseSizeFilterInput(options.maxSize);
+                const minSize = parseSizeFilterInput(options.minSize);
+                const normalizedUseCase = normalizeUseCaseInput(options.useCase);
+
+                analysisResult = await checker.analyze({
+                    useCase: normalizedUseCase,
+                    includeCloud: Boolean(options.includeCloud),
+                    limit: Number.parseInt(options.limit, 10) || 25,
+                    maxSize,
+                    minSize,
+                    runtime: selectedRuntime
+                });
+
+                runtimeBackend = selectedRuntime;
+                policyCandidates = collectCandidatesFromAnalysis(analysisResult);
+            } else {
+                recommendationResult = await checker.generateIntelligentRecommendations(hardware);
+                if (!recommendationResult) {
+                    throw new Error('Unable to generate recommendation data for policy audit export.');
+                }
+
+                runtimeBackend = normalizeRuntime(options.runtime || 'ollama');
+                policyCandidates = collectCandidatesFromRecommendationData(recommendationResult);
+            }
+
+            const policyContext = buildPolicyRuntimeContext({
+                hardware,
+                runtimeBackend
+            });
+
+            const policyEvaluation = evaluatePolicyCandidates(
+                policyConfig.policyEngine,
+                policyCandidates,
+                policyContext,
+                policyConfig.policy
+            );
+            const policyEnforcement = resolvePolicyEnforcement(policyConfig.policy, policyEvaluation);
+
+            const report = buildComplianceReport({
+                commandName: selectedCommand,
+                policyPath: policyConfig.policyPath,
+                policy: policyConfig.policy,
+                evaluation: policyEvaluation,
+                enforcement: policyEnforcement,
+                runtimeContext: policyContext,
+                options: {
+                    format: exportFormats,
+                    runtime: runtimeBackend,
+                    use_case: selectedCommand === 'check' ? normalizeUseCaseInput(options.useCase) : null,
+                    category: selectedCommand === 'recommend' ? options.category || null : null,
+                    include_cloud: Boolean(options.includeCloud)
+                },
+                hardware
+            });
+
+            const generatedAt = report.generated_at || new Date().toISOString();
+            const writtenFiles = [];
+            exportFormats.forEach((format) => {
+                const filePath = toAuditOutputPath({
+                    outputPath: options.out,
+                    outputDir: options.outDir,
+                    commandName: selectedCommand,
+                    format,
+                    timestamp: generatedAt
+                });
+                const content = serializeComplianceReport(report, format);
+                writeReportFile(filePath, content);
+                writtenFiles.push({ format, filePath });
+            });
+
+            displayPolicySummary(`audit ${selectedCommand}`, policyConfig, policyEvaluation, policyEnforcement);
+
+            console.log('\n' + chalk.bgBlue.white.bold(' AUDIT EXPORT '));
+            writtenFiles.forEach((entry) => {
+                console.log(`${chalk.cyan(entry.format.toUpperCase())}: ${chalk.white(entry.filePath)}`);
+            });
+
+            if (policyEnforcement.shouldBlock) {
+                process.exit(policyEnforcement.exitCode);
+            }
+        } catch (error) {
+            console.error(chalk.red(`Audit export failed: ${error.message}`));
+            if (process.env.DEBUG) {
+                console.error(error.stack);
+            }
+            process.exit(1);
+        }
+    });
+
+auditCommand.action(() => {
+    auditCommand.outputHelp();
+});
+
 program
     .command('check')
     .description('Analyze your system and show compatible LLM models')
@@ -1992,15 +2444,31 @@ program
     .option('--min-size <size>', 'Minimum model size to consider (e.g., "7B" or "7GB")')
     .option('--include-cloud', 'Include cloud models in analysis')
     .option('--ollama-only', 'Only show models available in Ollama')
+    .option('--runtime <runtime>', `Inference runtime (${SUPPORTED_RUNTIMES.join('|')})`, 'ollama')
+    .option('--policy <file>', 'Evaluate candidate models against a policy file')
     .option('--performance-test', 'Run performance benchmarks')
     .option('--show-ollama-analysis', 'Show detailed Ollama model analysis')
     .option('--no-verbose', 'Disable step-by-step progress display')
+    .addHelpText(
+        'after',
+        `
+Enterprise policy examples:
+  $ llm-checker check --policy ./policy.yaml
+  $ llm-checker check --policy ./policy.yaml --use-case coding --runtime vllm
+  $ llm-checker check --policy ./policy.yaml --include-cloud --max-size 24B
+
+Policy scope:
+  - Evaluates all compatible and marginal candidates discovered during analysis
+  - Not limited to the top --limit results shown in output
+`
+    )
     .action(async (options) => {
         showAsciiArt('check');
         try {
             // Use verbose progress unless explicitly disabled
             const verboseEnabled = options.verbose !== false;
             const checker = new (getLLMChecker())({ verbose: verboseEnabled });
+            const policyConfig = options.policy ? loadPolicyConfiguration(options.policy) : null;
             
             // If verbose is disabled, show simple loading message
             if (!verboseEnabled) {
@@ -2008,6 +2476,16 @@ program
             }
 
             const hardware = await checker.getSystemInfo();
+            let selectedRuntime = normalizeRuntime(options.runtime);
+            if (!runtimeSupportedOnHardware(selectedRuntime, hardware)) {
+                const runtimeLabel = getRuntimeDisplayName(selectedRuntime);
+                console.log(
+                    chalk.yellow(
+                        `\nWarning: ${runtimeLabel} is not supported on this hardware. Falling back to Ollama.`
+                    )
+                );
+                selectedRuntime = 'ollama';
+            }
             
             // Normalize and fix use-case typos
             const normalizeUseCase = (useCase = '') => {
@@ -2049,17 +2527,48 @@ program
                 performanceTest: options.performanceTest,
                 limit: parseInt(options.limit) || 10,
                 maxSize: maxSize,
-                minSize: minSize
+                minSize: minSize,
+                runtime: selectedRuntime
             });
 
             if (!verboseEnabled) {
                 console.log(chalk.green(' done'));
             }
 
+            let policyEvaluation = null;
+            let policyEnforcement = null;
+            if (policyConfig) {
+                const policyCandidates = collectCandidatesFromAnalysis(analysis);
+                const policyContext = buildPolicyRuntimeContext({
+                    hardware,
+                    runtimeBackend: selectedRuntime
+                });
+                policyEvaluation = evaluatePolicyCandidates(
+                    policyConfig.policyEngine,
+                    policyCandidates,
+                    policyContext,
+                    policyConfig.policy
+                );
+                policyEnforcement = resolvePolicyEnforcement(policyConfig.policy, policyEvaluation);
+            }
+
             // Simplified output - show only essential information
             displaySimplifiedSystemInfo(hardware);
-            const recommendedModels = await displayModelRecommendations(analysis, hardware, normalizedUseCase, parseInt(options.limit) || 1);
-            await displayQuickStartCommands(analysis, recommendedModels[0], recommendedModels);
+            const recommendedModels = await displayModelRecommendations(
+                analysis,
+                hardware,
+                normalizedUseCase,
+                parseInt(options.limit) || 1,
+                selectedRuntime
+            );
+            await displayQuickStartCommands(analysis, recommendedModels[0], recommendedModels, selectedRuntime);
+
+            if (policyConfig && policyEvaluation && policyEnforcement) {
+                displayPolicySummary('check', policyConfig, policyEvaluation, policyEnforcement);
+                if (policyEnforcement.shouldBlock) {
+                    process.exit(policyEnforcement.exitCode);
+                }
+            }
 
         } catch (error) {
             console.error(chalk.red('\nError:'), error.message);
@@ -2290,11 +2799,22 @@ program
     .description('Get intelligent model recommendations for your hardware')
     .option('-c, --category <category>', 'Get recommendations for specific category (coding, talking, reading, etc.)')
     .option('--no-verbose', 'Disable step-by-step progress display')
+    .option('--policy <file>', 'Evaluate recommendations against a policy file')
+    .addHelpText(
+        'after',
+        `
+Enterprise policy examples:
+  $ llm-checker recommend --policy ./policy.yaml
+  $ llm-checker recommend --policy ./policy.yaml --category coding
+  $ llm-checker recommend --policy ./policy.yaml --no-verbose
+`
+    )
     .action(async (options) => {
         showAsciiArt('recommend');
         try {
             const verboseEnabled = options.verbose !== false;
             const checker = new (getLLMChecker())({ verbose: verboseEnabled });
+            const policyConfig = options.policy ? loadPolicyConfiguration(options.policy) : null;
             
             if (!verboseEnabled) {
                 process.stdout.write(chalk.gray('Generating recommendations...'));
@@ -2312,12 +2832,36 @@ program
                 console.log(chalk.green(' done'));
             }
 
+            let policyEvaluation = null;
+            let policyEnforcement = null;
+            if (policyConfig) {
+                const policyCandidates = collectCandidatesFromRecommendationData(intelligentRecommendations);
+                const policyContext = buildPolicyRuntimeContext({
+                    hardware,
+                    runtimeBackend: 'ollama'
+                });
+                policyEvaluation = evaluatePolicyCandidates(
+                    policyConfig.policyEngine,
+                    policyCandidates,
+                    policyContext,
+                    policyConfig.policy
+                );
+                policyEnforcement = resolvePolicyEnforcement(policyConfig.policy, policyEvaluation);
+            }
+
             // Mostrar información del sistema
             displaySystemInfo(hardware, { summary: { hardwareTier: intelligentRecommendations.summary.hardware_tier } });
             
             // Mostrar recomendaciones
             displayIntelligentRecommendations(intelligentRecommendations);
 
+            if (policyConfig && policyEvaluation && policyEnforcement) {
+                displayPolicySummary('recommend', policyConfig, policyEvaluation, policyEnforcement);
+                if (policyEnforcement.shouldBlock) {
+                    process.exit(policyEnforcement.exitCode);
+                }
+            }
+
         } catch (error) {
             console.error(chalk.red('\nError:'), error.message);
             if (process.env.DEBUG) {