llm-checker 3.2.7 → 3.3.0

package/README.md

@@ -22,8 +22,11 @@
 </p>
 
 <p align="center">
+  <a href="#start-here-2-minutes">Start Here</a> &bull;
   <a href="#installation">Installation</a> &bull;
   <a href="#quick-start">Quick Start</a> &bull;
+  <a href="#calibration-quick-start-10-minutes">Calibration Quick Start</a> &bull;
+  <a href="https://github.com/Pavelevich/llm-checker/tree/main/docs">Docs</a> &bull;
   <a href="#claude-code-mcp">Claude MCP</a> &bull;
   <a href="#commands">Commands</a> &bull;
   <a href="#scoring-system">Scoring</a> &bull;
@@ -54,6 +57,17 @@ Choosing the right LLM for your hardware is complex. With thousands of model var
 
 ---
 
+## Documentation
+
+- [Docs Hub](https://github.com/Pavelevich/llm-checker/tree/main/docs)
+- [Usage Guide](https://github.com/Pavelevich/llm-checker/blob/main/docs/guides/usage-guide.md)
+- [Advanced Usage](https://github.com/Pavelevich/llm-checker/blob/main/docs/guides/advanced-usage.md)
+- [Technical Reference](https://github.com/Pavelevich/llm-checker/blob/main/docs/reference/technical-docs.md)
+- [Changelog](https://github.com/Pavelevich/llm-checker/blob/main/docs/reference/changelog.md)
+- [Calibration Fixtures](https://github.com/Pavelevich/llm-checker/tree/main/docs/fixtures/calibration)
+
+---
+
 ## Comparison with Other Tooling (e.g. `llmfit`)
 
 LLM Checker and `llmfit` solve related but different problems:
@@ -89,6 +103,32 @@ npm install sql.js
 
 ---
 
+## Start Here (2 Minutes)
+
+If you are new, use this exact flow:
+
+```bash
+# 1) Install
+npm install -g llm-checker
+
+# 2) Detect your hardware
+llm-checker hw-detect
+
+# 3) Get recommendations by category
+llm-checker recommend --category coding
+
+# 4) Run with auto-selection
+llm-checker ai-run --category coding --prompt "Write a hello world in Python"
+```
+
+If you already calibrated routing:
+
+```bash
+llm-checker ai-run --calibrated --category coding --prompt "Refactor this function"
+```
+
+---
+
 ## Distribution
 
 LLM Checker is published in all primary channels:
@@ -97,17 +137,16 @@ LLM Checker is published in all primary channels:
 - GitHub Releases: [Release history](https://github.com/Pavelevich/llm-checker/releases)
 - GitHub Packages: [`@pavelevich/llm-checker`](https://github.com/users/Pavelevich/packages/npm/package/llm-checker)
 
-### v3.2.7 Highlights
-
-- License updated to **NPDL-1.0**: paid redistribution and paid hosted/API delivery now require a separate commercial license.
+### v3.3.0 Highlights
 
-- Recommendation engine now enforces feasible 30B-class coverage on high-capacity discrete multi-GPU setups (for non-speed objectives).
-- Heterogeneous GPU inventories are preserved in output summaries and downstream recommendation inputs.
-- Added and validated fallback mappings/paths for:
-  - AMD Radeon AI PRO R9700 (PCI ID `7551`)
-  - NVIDIA GTX 1070 Ti (device `1b82`)
-  - Linux RX 7900 XTX detection via non-ROCm fallbacks (`lspci`/`sysfs`)
-- Expanded deterministic and hardware regression coverage for multi-GPU and unified-memory edge cases.
+- Calibrated routing is now first-class in `recommend` and `ai-run`:
+  - `--calibrated [file]` support with default discovery path.
+  - clear precedence: `--policy` > `--calibrated` > deterministic fallback.
+  - routing provenance output (source, route, selected model).
+- New calibration fixtures and end-to-end tests for:
+  - `calibrate --policy-out ...` → `recommend --calibrated ...`
+- Hardened Jetson CUDA detection to avoid false CPU-only fallback.
+- Documentation reorganized under `docs/` with clearer onboarding paths.
 
 ### Optional: Install from GitHub Packages
 
@@ -141,6 +180,51 @@ llm-checker search qwen --use-case coding
 
 ---
 
+## Calibration Quick Start (10 Minutes)
+
+This path produces both calibration artifacts and verifies calibrated routing in one pass.
+
+### 1) Use the sample prompt suite
+
+```bash
+cp ./docs/fixtures/calibration/sample-suite.jsonl ./sample-suite.jsonl
+```
+
+### 2) Generate calibration artifacts (dry-run)
+
+```bash
+mkdir -p ./artifacts
+llm-checker calibrate \
+  --suite ./sample-suite.jsonl \
+  --models qwen2.5-coder:7b llama3.2:3b \
+  --runtime ollama \
+  --objective balanced \
+  --dry-run \
+  --output ./artifacts/calibration-result.json \
+  --policy-out ./artifacts/calibration-policy.yaml
+```
+
+Artifacts created:
+
+- `./artifacts/calibration-result.json` (calibration contract)
+- `./artifacts/calibration-policy.yaml` (routing policy for runtime commands)
+
+### 3) Apply calibrated routing
+
+```bash
+llm-checker recommend --calibrated ./artifacts/calibration-policy.yaml --category coding
+llm-checker ai-run --calibrated ./artifacts/calibration-policy.yaml --category coding --prompt "Refactor this function"
+```
+
+Notes:
+
+- `--policy <file>` has precedence over `--calibrated [file]`.
+- If `--calibrated` has no path, discovery uses `~/.llm-checker/calibration-policy.{yaml,yml,json}`.
+- `--mode full` currently requires `--runtime ollama`.
+- `./docs/fixtures/calibration/sample-generated-policy.yaml` shows the expected policy structure.
+
+---
+
 ## Claude Code MCP
 
 LLM Checker includes a built-in [Model Context Protocol](https://modelcontextprotocol.io/) (MCP) server, allowing **Claude Code** and other MCP-compatible AI assistants to analyze your hardware and manage local models directly.
@@ -223,6 +307,7 @@ Claude will automatically call the right tools and give you actionable results.
 | `hw-detect` | Detect GPU/CPU capabilities, memory, backends |
 | `check` | Full system analysis with compatible models and recommendations |
 | `recommend` | Intelligent recommendations by category (coding, reasoning, multimodal, etc.) |
+| `calibrate` | Generate calibration result + routing policy artifacts from a JSONL prompt suite |
 | `installed` | Rank your installed Ollama models by compatibility |
 
 ### Advanced Commands (require `sql.js`)
@@ -257,6 +342,28 @@ llm-checker check --policy ./policy.yaml --use-case coding --runtime vllm
 llm-checker recommend --policy ./policy.yaml --category coding
 ```
 
+### Calibrated Routing in `recommend` and `ai-run`
+
+`recommend` and `ai-run` now support calibration routing policies generated by `calibrate --policy-out`.
+
+- `--calibrated [file]`:
+  - If `file` is omitted, discovery defaults to `~/.llm-checker/calibration-policy.{yaml,yml,json}`.
+- `--policy <file>` takes precedence over `--calibrated` for routing resolution.
+- Resolution precedence:
+  - `--policy` (explicit)
+  - `--calibrated` (explicit file or default discovery)
+  - deterministic selector fallback
+- CLI output includes routing provenance (`--policy`, `--calibrated`, or default discovery) and the selected route/model.
+
+Examples:
+
+```bash
+llm-checker recommend --calibrated --category coding
+llm-checker recommend --calibrated ./calibration-policy.yaml --category reasoning
+llm-checker ai-run --calibrated --category coding --prompt "Refactor this function"
+llm-checker ai-run --policy ./calibration-policy.yaml --prompt "Summarize this report"
+```
+
 ### Policy Audit Export
 
 Use `audit export` when you need machine-readable compliance evidence for CI/CD gates, governance reviews, or security tooling.
@@ -716,7 +823,7 @@ LLM Checker is licensed under **NPDL-1.0** (No Paid Distribution License).
 - Free use, modification, and redistribution are allowed.
 - Selling the software or offering it as a paid hosted/API service is not allowed without a separate commercial license.
 
-See [LICENSE](LICENSE) for full terms.
+See [LICENSE](https://github.com/Pavelevich/llm-checker/blob/main/LICENSE) for full terms.
 
 ---
 

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 = {
@@ -1073,6 +1084,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 +2565,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')
@@ -2809,6 +3049,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 +3060,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 +3072,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 +3115,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 +3386,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 +3406,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 +3438,10 @@ program
                     return;
                 }
             }
+
+            candidateModels = Array.isArray(candidateModels)
+                ? candidateModels.filter((model) => typeof model === 'string' && model.trim().length > 0)
+                : [];
             
             // AI selection
             const systemSpecs = {
@@ -3175,10 +3452,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.7",
+  "version": "3.3.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",