llm-checker 3.2.8 → 3.4.0

package/bin/enhanced_cli.js

@@ -23,6 +23,16 @@ const {
     getRuntimeDisplayName,
     getRuntimeCommandSet
 } = require('../src/runtime/runtime-support');
+const { CalibrationManager } = require('../src/calibration/calibration-manager');
+const { SUPPORTED_CALIBRATION_OBJECTIVES } = require('../src/calibration/schemas');
+const {
+    resolveRoutingPolicyPreference,
+    normalizeTaskName,
+    inferTaskFromPrompt,
+    resolveCalibrationRoute,
+    getRouteModelCandidates,
+    selectModelFromRoute
+} = require('../src/calibration/policy-routing');
 const SpeculativeDecodingEstimator = require('../src/models/speculative-decoding-estimator');
 const PolicyManager = require('../src/policy/policy-manager');
 const PolicyEngine = require('../src/policy/policy-engine');
@@ -38,6 +48,7 @@ const {
     serializeComplianceReport
 } = require('../src/policy/audit-reporter');
 const policyManager = new PolicyManager();
+const calibrationManager = new CalibrationManager();
 
 // ASCII Art for each command - Large text banners
 const ASCII_ART = {
@@ -580,6 +591,80 @@ async function checkOllamaAndExit() {
     }
 }
 
+function parsePositiveIntegerOption(rawValue, optionName) {
+    const parsed = Number(rawValue);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new Error(`Invalid ${optionName}: ${rawValue}`);
+    }
+    return Math.round(parsed);
+}
+
+function parseNonNegativeNumberOption(rawValue, optionName) {
+    const parsed = Number(rawValue);
+    if (!Number.isFinite(parsed) || parsed < 0) {
+        throw new Error(`Invalid ${optionName}: ${rawValue}`);
+    }
+    return parsed;
+}
+
+function selectModelsForPlan(installedModels, requestedModels = []) {
+    const requested = Array.isArray(requestedModels)
+        ? requestedModels.map((model) => String(model || '').trim()).filter(Boolean)
+        : [];
+
+    if (!requested.length) {
+        return {
+            selected: installedModels.slice(),
+            missing: []
+        };
+    }
+
+    const selected = [];
+    const missing = [];
+    const seen = new Set();
+
+    for (const request of requested) {
+        const normalized = request.toLowerCase();
+
+        let match = installedModels.find(
+            (model) => String(model.name || '').toLowerCase() === normalized
+        );
+
+        if (!match) {
+            match = installedModels.find((model) =>
+                String(model.name || '').toLowerCase().startsWith(`${normalized}:`)
+            );
+        }
+
+        if (!match) {
+            match = installedModels.find(
+                (model) => String(model.family || '').toLowerCase() === normalized
+            );
+        }
+
+        if (!match) {
+            match = installedModels.find((model) =>
+                String(model.name || '').toLowerCase().includes(normalized)
+            );
+        }
+
+        if (!match) {
+            missing.push(request);
+            continue;
+        }
+
+        if (!seen.has(match.name)) {
+            selected.push(match);
+            seen.add(match.name);
+        }
+    }
+
+    return {
+        selected,
+        missing
+    };
+}
+
 function getStatusIcon(model, ollamaModels) {
     const ollamaModel = ollamaModels?.find(om => om.matchedModel?.name === model.name);
 
@@ -1073,6 +1158,119 @@ function displayIntelligentRecommendations(intelligentData) {
     console.log(chalk.red('╰'));
 }
 
+function toCalibrationSourceLabel(source) {
+    if (source === 'default-discovery') {
+        return '~/.llm-checker/calibration-policy.{yaml,yml,json}';
+    }
+    return source || 'unknown';
+}
+
+function collectRecommendationModelIdentifiers(intelligentData) {
+    const identifiers = new Set();
+    const summary = intelligentData?.summary || {};
+
+    if (summary.best_overall?.identifier) {
+        identifiers.add(summary.best_overall.identifier);
+    }
+
+    if (summary.by_category && typeof summary.by_category === 'object') {
+        Object.values(summary.by_category).forEach((entry) => {
+            if (entry?.identifier) {
+                identifiers.add(entry.identifier);
+            }
+        });
+    }
+
+    const recommendationGroups = intelligentData?.recommendations || {};
+    Object.values(recommendationGroups).forEach((group) => {
+        const models = Array.isArray(group?.bestModels) ? group.bestModels : [];
+        models.forEach((model) => {
+            if (model?.model_identifier) {
+                identifiers.add(model.model_identifier);
+            }
+        });
+    });
+
+    return Array.from(identifiers);
+}
+
+function resolveCalibratedRouteDecision(calibratedPolicy, requestedTask, availableModels = []) {
+    if (!calibratedPolicy?.policy) return null;
+
+    const resolvedRoute = resolveCalibrationRoute(calibratedPolicy.policy, requestedTask);
+    if (!resolvedRoute?.route) return null;
+
+    const routeCandidates = getRouteModelCandidates(resolvedRoute.route);
+    const routeSelection = selectModelFromRoute(resolvedRoute.route, availableModels);
+
+    const selectedModel = routeSelection?.selectedModel || routeCandidates[0] || null;
+
+    return {
+        requestedTask: resolvedRoute.requestedTask,
+        resolvedTask: resolvedRoute.resolvedTask,
+        usedTaskFallback: Boolean(resolvedRoute.usedTaskFallback),
+        primary: resolvedRoute.route.primary,
+        fallbacks: Array.isArray(resolvedRoute.route.fallbacks) ? resolvedRoute.route.fallbacks : [],
+        routeCandidates,
+        selectedModel,
+        matchedRouteModel: routeSelection?.matchedRouteModel || (routeCandidates[0] || null),
+        matchedAvailableModel: Boolean(routeSelection),
+        usedRouteFallbackModel: Boolean(routeSelection?.usedFallback)
+    };
+}
+
+function displayCalibratedRoutingDecision(commandName, calibratedPolicy, routeDecision, warnings = []) {
+    if (!calibratedPolicy && (!warnings || warnings.length === 0)) {
+        return;
+    }
+
+    console.log('\n' + chalk.bgBlue.white.bold(' CALIBRATED ROUTING '));
+    console.log(chalk.blue('╭' + '─'.repeat(78)));
+    console.log(chalk.blue('│') + ` Command: ${chalk.cyan(commandName)}`);
+
+    if (calibratedPolicy) {
+        console.log(chalk.blue('│') + ` Policy: ${chalk.green(calibratedPolicy.policyPath)}`);
+        console.log(chalk.blue('│') + ` Source: ${chalk.magenta(toCalibrationSourceLabel(calibratedPolicy.source))}`);
+    } else {
+        console.log(chalk.blue('│') + chalk.yellow(' Policy: not active (deterministic fallback)'));
+    }
+
+    if (routeDecision) {
+        const requestedTask = routeDecision.requestedTask || 'general';
+        const resolvedTask = routeDecision.resolvedTask || requestedTask;
+        const taskDisplay = routeDecision.usedTaskFallback
+            ? `${requestedTask} → ${resolvedTask}`
+            : requestedTask;
+
+        const selectedModel = routeDecision.selectedModel || routeDecision.primary || 'N/A';
+        const selectedLabel = routeDecision.usedRouteFallbackModel
+            ? `${selectedModel} (fallback)`
+            : selectedModel;
+
+        console.log(chalk.blue('│') + ` Task: ${chalk.white(taskDisplay)}`);
+        console.log(chalk.blue('│') + ` Route primary: ${chalk.green(routeDecision.primary || 'N/A')}`);
+        if (routeDecision.fallbacks && routeDecision.fallbacks.length > 0) {
+            console.log(chalk.blue('│') + ` Route fallbacks: ${chalk.gray(routeDecision.fallbacks.join(', '))}`);
+        }
+        console.log(chalk.blue('│') + ` Selected model: ${chalk.green.bold(selectedLabel)}`);
+
+        if (!routeDecision.matchedAvailableModel) {
+            console.log(
+                chalk.blue('│') +
+                    chalk.yellow(' Route did not match local/recommended models; using route primary for visibility.')
+            );
+        }
+    }
+
+    if (warnings && warnings.length > 0) {
+        warnings.forEach((warning) => {
+            console.log(chalk.blue('│') + chalk.yellow(` Warning: ${warning}`));
+        });
+    }
+
+    console.log(chalk.blue('╰'));
+}
+
 function displayModelsStats(originalCount, filteredCount, options) {
     console.log('\n' + chalk.bgGreen.white.bold('  DATABASE STATS '));
     console.log(chalk.green('╭' + '─'.repeat(60)));
@@ -2441,6 +2639,122 @@ auditCommand.action(() => {
     auditCommand.outputHelp();
 });
 
+program
+    .command('calibrate')
+    .description('Generate calibration contract artifacts from a JSONL prompt suite')
+    .requiredOption('--suite <file>', 'Prompt suite path in JSONL format')
+    .requiredOption(
+        '--models <identifiers...>',
+        'Model identifiers to include (repeat flag and/or comma-separate values)'
+    )
+    .requiredOption(
+        '--output <file>',
+        'Calibration result output path (.json, .yaml, or .yml)'
+    )
+    .option(
+        '--runtime <runtime>',
+        `Inference runtime (${SUPPORTED_RUNTIMES.join('|')})`,
+        'ollama'
+    )
+    .option(
+        '--mode <mode>',
+        'Execution mode (dry-run|contract-only|full). Default: contract-only'
+    )
+    .option(
+        '--objective <objective>',
+        `Calibration objective (${SUPPORTED_CALIBRATION_OBJECTIVES.join('|')})`,
+        'balanced'
+    )
+    .option(
+        '--policy-out <file>',
+        'Optional calibration policy output path (.json, .yaml, or .yml)'
+    )
+    .option('--warmup <count>', 'Warmup runs per prompt in full mode', '1')
+    .option('--iterations <count>', 'Measured iterations per prompt in full mode', '2')
+    .option('--timeout-ms <ms>', 'Per-prompt timeout in full mode', '120000')
+    .option('--dry-run', 'Produce draft artifacts without benchmark execution')
+    .addHelpText(
+        'after',
+        `
+Examples:
+  $ llm-checker calibrate --suite ./prompts.jsonl --models qwen2.5-coder:7b llama3.2:3b --output ./calibration.json
+  $ llm-checker calibrate --suite ./prompts.jsonl --models qwen2.5-coder:7b --mode full --iterations 3 --output ./calibration.json --policy-out ./routing.yaml
+  $ llm-checker calibrate --suite ./prompts.jsonl --models qwen2.5-coder:7b,llama3.2:3b --output ./calibration.yaml --policy-out ./routing.yaml --dry-run
+`
+    )
+    .action((options) => {
+        try {
+            const runtime = calibrationManager.validateRuntime(options.runtime);
+            const objective = calibrationManager.validateObjective(options.objective);
+            const executionMode = calibrationManager.resolveExecutionMode({
+                mode: options.mode,
+                dryRun: Boolean(options.dryRun)
+            });
+            const models = calibrationManager.parseModelIdentifiers(options.models);
+            const suite = calibrationManager.parsePromptSuite(options.suite);
+
+            let calibrationResult = null;
+            if (executionMode === 'full') {
+                calibrationResult = calibrationManager.runFullCalibration({
+                    models,
+                    suite,
+                    runtime,
+                    objective,
+                    benchmarkConfig: {
+                        warmupRuns: Number.parseInt(options.warmup, 10),
+                        measuredIterations: Number.parseInt(options.iterations, 10),
+                        timeoutMs: Number.parseInt(options.timeoutMs, 10)
+                    }
+                });
+            } else {
+                calibrationResult = calibrationManager.buildDraftCalibrationResult({
+                    models,
+                    suiteMetadata: suite.metadata,
+                    runtime,
+                    objective,
+                    executionMode
+                });
+            }
+
+            const resultPath = calibrationManager.writeArtifact(options.output, calibrationResult);
+
+            let policyPath = null;
+            if (options.policyOut) {
+                const calibrationPolicy = calibrationManager.buildDraftCalibrationPolicy({
+                    calibrationResult,
+                    calibrationResultPath: resultPath
+                });
+                policyPath = calibrationManager.writeArtifact(options.policyOut, calibrationPolicy);
+            }
+
+            console.log('\n' + chalk.bgBlue.white.bold(' CALIBRATION ARTIFACTS GENERATED '));
+            console.log(chalk.blue('╭' + '─'.repeat(72)));
+            console.log(chalk.blue('│') + ` Suite: ${chalk.white(suite.path)}`);
+            console.log(chalk.blue('│') + ` Runtime: ${chalk.cyan(runtime)} | Objective: ${chalk.cyan(objective)}`);
+            console.log(chalk.blue('│') + ` Models: ${chalk.white(String(models.length))}`);
+            console.log(chalk.blue('│') + ` Execution mode: ${chalk.yellow(executionMode)}`);
+            if (executionMode === 'full') {
+                console.log(
+                    chalk.blue('│') +
+                        ` Successful: ${chalk.green(
+                            String(calibrationResult.summary.successful_models)
+                        )} | Failed: ${chalk.red(String(calibrationResult.summary.failed_models))}`
+                );
+            }
+            console.log(chalk.blue('│') + ` Result: ${chalk.green(resultPath)}`);
+            if (policyPath) {
+                console.log(chalk.blue('│') + ` Policy: ${chalk.green(policyPath)}`);
+            }
+            console.log(chalk.blue('╰' + '─'.repeat(72)));
+        } catch (error) {
+            console.error(chalk.red(`Calibration failed: ${error.message}`));
+            if (process.env.DEBUG) {
+                console.error(error.stack);
+            }
+            process.exit(1);
+        }
+    });
+
 program
     .command('check')
     .description('Analyze your system and show compatible LLM models')
@@ -2802,6 +3116,145 @@ program
         }
     });
 
+program
+    .command('ollama-plan')
+    .description('Plan safe Ollama runtime settings for selected local models')
+    .option('--models <models...>', 'Model tags/families to include (default: all local models)')
+    .option('--ctx <tokens>', 'Target context window in tokens', '8192')
+    .option('--concurrency <n>', 'Target parallel request count', '2')
+    .option('--objective <mode>', 'Optimization objective (latency|balanced|throughput)', 'balanced')
+    .option('--reserve-gb <gb>', 'Memory reserve for OS and background workloads', '2')
+    .option('--json', 'Output plan as JSON')
+    .action(async (options) => {
+        const spinner = options.json ? null : ora('Building Ollama capacity plan...').start();
+
+        try {
+            const requestedObjective = String(options.objective || 'balanced').toLowerCase();
+            const supportedObjectives = new Set(['latency', 'balanced', 'throughput']);
+            if (!supportedObjectives.has(requestedObjective)) {
+                throw new Error(`Invalid objective "${options.objective}". Use latency, balanced, or throughput.`);
+            }
+
+            const targetContext = parsePositiveIntegerOption(options.ctx, '--ctx');
+            const targetConcurrency = parsePositiveIntegerOption(options.concurrency, '--concurrency');
+            const reserveGB = parseNonNegativeNumberOption(options.reserveGb, '--reserve-gb');
+
+            const OllamaClient = require('../src/ollama/client');
+            const UnifiedDetector = require('../src/hardware/unified-detector');
+            const OllamaCapacityPlanner = require('../src/ollama/capacity-planner');
+
+            const ollamaClient = new OllamaClient();
+            const availability = await ollamaClient.checkOllamaAvailability();
+            if (!availability.available) {
+                throw new Error(availability.error || 'Ollama is not available');
+            }
+
+            const localModels = await ollamaClient.getLocalModels();
+            if (!localModels || localModels.length === 0) {
+                throw new Error('No local Ollama models found. Install one with: ollama pull llama3.2:3b');
+            }
+
+            const { selected, missing } = selectModelsForPlan(localModels, options.models || []);
+            if (selected.length === 0) {
+                throw new Error(
+                    `No matching local models found for: ${(options.models || []).join(', ')}`
+                );
+            }
+
+            const detector = new UnifiedDetector();
+            const hardware = await detector.detect();
+            const planner = new OllamaCapacityPlanner();
+
+            const plan = planner.plan({
+                hardware,
+                models: selected,
+                targetContext,
+                targetConcurrency,
+                objective: requestedObjective,
+                reserveGB
+            });
+
+            if (options.json) {
+                console.log(JSON.stringify({
+                    generated_at: new Date().toISOString(),
+                    selection: {
+                        requested: options.models || [],
+                        selected: selected.map((model) => model.name),
+                        missing
+                    },
+                    plan
+                }, null, 2));
+                return;
+            }
+
+            if (spinner) spinner.succeed('Capacity plan generated');
+
+            console.log('\n' + chalk.bgBlue.white.bold(' OLLAMA CAPACITY PLAN '));
+            console.log(
+                chalk.blue('Hardware:'),
+                `${plan.hardware.backendName} (${plan.hardware.backend})`
+            );
+            console.log(
+                chalk.blue('Memory budget:'),
+                `${plan.memory.budgetGB}GB usable (reserve ${plan.hardware.reserveGB}GB)`
+            );
+
+            if (missing.length > 0) {
+                console.log(
+                    chalk.yellow('Missing model filters:'),
+                    missing.join(', ')
+                );
+            }
+
+            console.log(chalk.blue.bold('\nSelected models:'));
+            for (const model of plan.models) {
+                console.log(
+                    `  - ${model.name} (${model.size}, ~${model.estimatedBaseMemoryGB}GB base)`
+                );
+            }
+
+            console.log(chalk.blue.bold('\nRecommended envelope:'));
+            console.log(
+                `  Context: ${plan.envelope.context.recommended} (requested ${plan.envelope.context.requested})`
+            );
+            console.log(
+                `  Parallel: ${plan.envelope.parallel.recommended} (requested ${plan.envelope.parallel.requested})`
+            );
+            console.log(
+                `  Loaded models: ${plan.envelope.loaded_models.recommended} (requested ${plan.envelope.loaded_models.requested})`
+            );
+            console.log(
+                `  Estimated memory: ${plan.memory.recommendedEstimatedGB}GB / ${plan.memory.budgetGB}GB (${plan.memory.utilizationPercent}%)`
+            );
+            console.log(`  Risk: ${plan.risk.level.toUpperCase()} (${plan.risk.score}/100)`);
+
+            if (plan.notes.length > 0) {
+                console.log(chalk.blue.bold('\nNotes:'));
+                for (const note of plan.notes) {
+                    console.log(`  - ${note}`);
+                }
+            }
+
+            console.log(chalk.blue.bold('\nRecommended env vars:'));
+            for (const [key, value] of Object.entries(plan.shell.env)) {
+                console.log(`  export ${key}=${value}`);
+            }
+
+            console.log(chalk.blue.bold('\nFallback profile:'));
+            console.log(
+                `  OLLAMA_NUM_CTX=${plan.fallback.num_ctx} OLLAMA_NUM_PARALLEL=${plan.fallback.num_parallel} OLLAMA_MAX_LOADED_MODELS=${plan.fallback.max_loaded_models}`
+            );
+            console.log('');
+        } catch (error) {
+            if (spinner) spinner.fail('Failed to build capacity plan');
+            console.error(chalk.red('Error:'), error.message);
+            if (process.env.DEBUG) {
+                console.error(error.stack);
+            }
+            process.exit(1);
+        }
+    });
+
 program
     .command('recommend')
     .description('Get intelligent model recommendations for your hardware')
@@ -2809,6 +3262,10 @@ 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(
+        '--calibrated [file]',
+        'Use calibrated routing policy (optional file path; defaults to ~/.llm-checker/calibration-policy.{yaml,yml,json})'
+    )
     .addHelpText(
         'after',
         `
@@ -2816,6 +3273,11 @@ 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
+
+Calibrated routing examples:
+  $ llm-checker recommend --calibrated --category coding
+  $ llm-checker recommend --calibrated ./calibration-policy.yaml --category reasoning
+  $ llm-checker recommend --policy ./calibration-policy.yaml --category coding
 `
     )
     .action(async (options) => {
@@ -2823,7 +3285,13 @@ Enterprise policy examples:
         try {
             const verboseEnabled = options.verbose !== false;
             const checker = new (getLLMChecker())({ verbose: verboseEnabled });
-            const policyConfig = options.policy ? loadPolicyConfiguration(options.policy) : null;
+            const routingPreference = resolveRoutingPolicyPreference({
+                policyOption: options.policy,
+                calibratedOption: options.calibrated,
+                loadEnterprisePolicy: loadPolicyConfiguration
+            });
+            const policyConfig = routingPreference.enterprisePolicy;
+            const calibratedPolicy = routingPreference.calibratedPolicy;
             
             if (!verboseEnabled) {
                 process.stdout.write(chalk.gray('Generating recommendations...'));
@@ -2860,11 +3328,18 @@ Enterprise policy examples:
                 policyEnforcement = resolvePolicyEnforcement(policyConfig.policy, policyEvaluation);
             }
 
+            const routingTask = normalizeTaskName(options.category || 'general');
+            const recommendationIdentifiers = collectRecommendationModelIdentifiers(intelligentRecommendations);
+            const routeDecision = calibratedPolicy
+                ? resolveCalibratedRouteDecision(calibratedPolicy, routingTask, recommendationIdentifiers)
+                : null;
+
             // Mostrar información del sistema
             displaySystemInfo(hardware, { summary: { hardwareTier: intelligentRecommendations.summary.hardware_tier } });
             
             // Mostrar recomendaciones
             displayIntelligentRecommendations(intelligentRecommendations);
+            displayCalibratedRoutingDecision('recommend', calibratedPolicy, routeDecision, routingPreference.warnings);
 
             if (policyConfig && policyEvaluation && policyEnforcement) {
                 displayPolicySummary('recommend', policyConfig, policyEvaluation, policyEnforcement);
@@ -3124,7 +3599,13 @@ program
     .command('ai-run')
     .description('AI-powered model selection and execution')
     .option('-m, --models <models...>', 'Specific models to choose from')
+    .option('-c, --category <category>', 'Task category hint (coding, reasoning, multimodal, general, etc.)')
     .option('--prompt <prompt>', 'Prompt to run with selected model')
+    .option('--policy <file>', 'Explicit calibrated routing policy file (takes precedence over --calibrated)')
+    .option(
+        '--calibrated [file]',
+        'Enable calibrated routing policy (optional file path; defaults to ~/.llm-checker/calibration-policy.{yaml,yml,json})'
+    )
     .action(async (options) => {
         showAsciiArt('ai-run');
         // Check if Ollama is installed first
@@ -3138,6 +3619,11 @@ program
             const aiSelector = new AIModelSelector();
             const checker = new (getLLMChecker())();
             const systemInfo = await checker.getSystemInfo();
+            const routingPreference = resolveRoutingPolicyPreference({
+                policyOption: options.policy,
+                calibratedOption: options.calibrated
+            });
+            const calibratedPolicy = routingPreference.calibratedPolicy;
             
             // Get available models or use provided ones
             let candidateModels = options.models;
@@ -3165,6 +3651,10 @@ program
                     return;
                 }
             }
+
+            candidateModels = Array.isArray(candidateModels)
+                ? candidateModels.filter((model) => typeof model === 'string' && model.trim().length > 0)
+                : [];
             
             // AI selection
             const systemSpecs = {
@@ -3175,10 +3665,33 @@ program
                 gpu_model_normalized: systemInfo.gpu?.model || 
                     (systemInfo.cpu?.manufacturer === 'Apple' ? 'apple_silicon' : 'cpu_only')
             };
-            
-            const result = await aiSelector.selectBestModel(candidateModels, systemSpecs);
+
+            const taskHint = normalizeTaskName(options.category || inferTaskFromPrompt(options.prompt));
+            const routeDecision = calibratedPolicy
+                ? resolveCalibratedRouteDecision(calibratedPolicy, taskHint, candidateModels)
+                : null;
+
+            let result;
+            if (routeDecision && routeDecision.matchedAvailableModel && routeDecision.selectedModel) {
+                result = {
+                    bestModel: routeDecision.selectedModel,
+                    confidence: routeDecision.usedRouteFallbackModel ? 0.82 : 0.94,
+                    method: 'calibrated-policy-route',
+                    reasoning: `Selected from calibrated policy route for ${routeDecision.resolvedTask}`
+                };
+            } else {
+                if (routeDecision && routeDecision.routeCandidates.length > 0) {
+                    routingPreference.warnings.push(
+                        `Calibrated route candidates (${routeDecision.routeCandidates.join(
+                            ', '
+                        )}) are not installed locally. Falling back to AI selector.`
+                    );
+                }
+                result = await aiSelector.selectBestModel(candidateModels, systemSpecs, taskHint);
+            }
             
             spinner.succeed(`Selected ${chalk.green.bold(result.bestModel)} (${result.method}, ${Math.round(result.confidence * 100)}% confidence)`);
+            displayCalibratedRoutingDecision('ai-run', calibratedPolicy, routeDecision, routingPreference.warnings);
             
             // Execute the selected model
             console.log(chalk.magenta.bold(`\nLaunching ${result.bestModel}...`));

package/package.json

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