@vierratale/ai 0.1.0-beta.13 → 0.1.0-beta.15

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vierratale
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -22,7 +22,7 @@ npx @vierratale/ai
 ```
 
 The first launch detects and, if needed, installs and starts the local engine
-(**Cortex** - "secretly" Ollama under the hood), then pulls the model you use.
+(**Cortex**), then pulls the model you use.
 
 ## Usage
 
@@ -32,36 +32,44 @@ vierrataleai --provider cortex        # Use local models
 vierrataleai --provider openai        # Use cloud models (OpenAI)
 vierrataleai --provider anthropic     # Use cloud models (Claude)
 vierrataleai --provider gemini        # Use cloud models (Gemini)
-vierrataleai --model VRTL-6.pro   # Use specific model
+vierrataleai --model VTL-3.7-Ultra   # Use specific model
 ```
 
 ## Models
 
 Local models run through the **Cortex** engine:
 
-| Model | Backend |
-|-------|---------|
-| VRTL-1.lite | qwen3:0.6b |
-| VRTL-2.fast | gemma3:1b |
-| VRTL-3.small | llama3.2:1b |
-| VRTL-4.balanced | qwen2.5:1.5b |
-| VRTL-5.plus | qwen3:1.7b |
-| VRTL-6.pro | qwen2.5:3b |
+| Model | Tier |
+|-------|------|
+| VTL-2.5-Mini | minimal |
+| VTL-2.7-Flash | fast |
+| VTL-2.9-Core | small |
+| VTL-3.2-Orbit | small |
+| VTL-3.1-Plus | balanced |
+| VTL-3.3-Pro | coder |
+| VTL-3.5-Reason | reasoning |
+| VTL-3.7-Ultra | ultra |
+| VTL-4.7-Gusto | balanced |
+| VTL-5.4-Tempo | balanced |
+| VTL-5.2-Pinnacle | pro |
+| VTL-5.9-Sovereign | pro |
 
 Cloud models are available when the matching provider + API key is configured:
 
-| Model | Backend |
-|-------|---------|
-| VRTL-7.cloud-mini | gpt-4o-mini (OpenAI) |
-| VRTL-8.cloud | gpt-4o (OpenAI) |
-| VRTL-9.cloud-fast | claude-3-5-haiku-20241022 (Anthropic) |
-| VRTL-10.cloud-pro | claude-sonnet-4-20250514 (Anthropic) |
-| VRTL-11.cloud-lite | gemini-2.0-flash (Gemini) |
-| VRTL-12.cloud-plus | gemini-1.5-pro (Gemini) |
-
-> Legacy `vierratale-*` model names (e.g. `vierratale-fast`, `vierratale-cloud`)
-
-> still work and are stored as VRTL names.
+| Model | Tier |
+|-------|------|
+| VTL-4.0 | cloud-mini |
+| VTL-4.2-Omni | cloud |
+| VTL-4.5-Plus | cloud-fast |
+| VTL-5.0-Pro | cloud-pro |
+| VTL-6.0-Reason | cloud-lite |
+| VTL-7.0-Omnij | cloud-plus |
+| VTL-8.0-Fabric | cloud-fabric |
+| VTL-9.0-Forge | cloud-forge |
+| VTL-10.0-Singularity | cloud-singularity |
+
+> Legacy `vierratale-*` and old `VRTL-*` model names (e.g. `vierratale-fast`,
+> `vierratale-cloud`) still work and map to the VTL names.
 
 ## Commands
 

package/bin/vierrataleai.js

@@ -9,11 +9,9 @@
 // Installation progress is always the fake animated bar — real engine/model
 // output is deliberately hidden so first-run feels quick and clean.
 import { run } from '../src/cli.js';
-import { Installer } from '../src/installer.js';
+import { Engine } from '../src/engine.js';
 import { Config } from '../src/config.js';
 import { Branding } from '../src/ui/branding.js';
-import { Terminal } from '../src/ui/terminal.js';
-import { dirname } from 'path';
 
 const C = Branding.colors;
 
@@ -63,19 +61,11 @@ async function main() {
 
   if (doInstall) {
     console.log(`\n  ${C.bold}${C.primary}${Branding.APP_NAME} ${Branding.VERSION}${C.reset} ${C.dim}— installer${C.reset}\n`);
-    const result = await fakeProgress(INSTALL_STEPS, Installer.install());
-    if (!result.command) {
-      Terminal.printInfo('Could not create a global command; run it via the bin script.');
-    } else {
-      Terminal.printSuccess(`Engine + model installed; "vierrataleai" (or "vierratale") command available at ${result.commandAlias || result.command}`);
-      if (!result.commandOnPath) {
-        Terminal.printInfo(`"vierrataleai" won't resolve in a new shell: add ${dirname(result.command)} to PATH, e.g. export PATH="$HOME/.local/bin:$PATH", then reopen the terminal.`);
-      }
-    }
+    await fakeProgress(INSTALL_STEPS, Engine.ensure());
     console.log();
   } else if (!quick) {
     // Auto-detect: install anything that's missing (engine, model) before starting.
-    await fakeProgress(READY_STEPS, Installer.ensure());
+    await fakeProgress(READY_STEPS, Engine.ensure());
     console.log();
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vierratale/ai",
-  "version": "0.1.0-beta.13",
+  "version": "0.1.0-beta.15",
   "description": "VierrataleAI - Intelligent terminal assistant",
   "type": "module",
   "license": "MIT",
@@ -18,6 +18,7 @@
     "bin",
     "src",
     "scripts",
+    "LICENSE",
     "README.md"
   ],
   "keywords": [

package/scripts/postinstall.js

@@ -25,9 +25,9 @@ try {
     execSync('curl -fsSL https://ollama.com/install.sh | sh', { stdio: 'inherit' });
   } else {
     console.log(
-      '\n[vierrataleai] The local engine (ollama) was not detected.\n' +
+      '\n[vierrataleai] The local engine was not detected.\n' +
         '  - Run the CLI: it will attempt to install and start the engine automatically.\n' +
-        '  - Or install it yourself: curl -fsSL https://ollama.com/install.sh | sh\n'
+        '  - Or run ./install.sh (in the project repo) to set up the engine.\n'
     );
   }
 } catch {

package/src/catalog.js

@@ -1,36 +1,59 @@
-// Model catalog. Display names use the countable VRTL branding:
-// VRTL-<number>.<word>, e.g. VRTL-2.fast, VRTL-7.cloud-mini.
+// Model catalog. Display names use the opaque VTL branding:
+// VTL-<number>.<name>, e.g. VTL-2.7-Flash, VTL-4.0.
+// The real engine tags are mapped to display names here and kept internal.
 const MODELS = {
-  'qwen3:0.6b': 'VRTL-1.lite',
-  'gemma3:1b': 'VRTL-2.fast',
-  'llama3.2:1b': 'VRTL-3.small',
-  'qwen2.5:1.5b': 'VRTL-4.balanced',
-  'qwen2.5-coder:1.5b': 'VRTL-4.coder',
-  'qwen3:1.7b': 'VRTL-5.plus',
-  'qwen2.5:3b': 'VRTL-6.pro',
-  'gpt-4o-mini': 'VRTL-7.cloud-mini',
-  'gpt-4o': 'VRTL-8.cloud',
-  'claude-3-5-haiku-20241022': 'VRTL-9.cloud-fast',
-  'claude-sonnet-4-20250514': 'VRTL-10.cloud-pro',
-  'gemini-2.0-flash': 'VRTL-11.cloud-lite',
-  'gemini-1.5-pro': 'VRTL-12.cloud-plus',
+  'qwen3:0.6b': 'VTL-2.5-Mini',
+  'gemma3:1b': 'VTL-2.7-Flash',
+  'llama3.2:1b': 'VTL-2.9-Core',
+  'llama3.2:3b': 'VTL-3.2-Orbit',
+  'qwen2.5:1.5b': 'VTL-3.1-Plus',
+  'qwen2.5-coder:1.5b': 'VTL-3.3-Pro',
+  'qwen3:1.7b': 'VTL-3.5-Reason',
+  'qwen2.5:3b': 'VTL-3.7-Ultra',
+  'gemma3:4b': 'VTL-4.7-Gusto',
+  'phi4-mini': 'VTL-5.4-Tempo',
+  'glm4:9b': 'VTL-5.2-Pinnacle',
+  'qwen3:4b': 'VTL-5.9-Sovereign',
+  'gpt-4o-mini': 'VTL-4.0',
+  'gpt-4o': 'VTL-4.2-Omni',
+  'claude-3-5-haiku-20241022': 'VTL-4.5-Plus',
+  'claude-sonnet-4-20250514': 'VTL-5.0-Pro',
+  'gemini-2.0-flash': 'VTL-6.0-Reason',
+  'gemini-1.5-pro': 'VTL-7.0-Omnij',
+  'kimi-k2.6:cloud': 'VTL-8.0-Fabric',
+  'kimi-k2.7-code:cloud': 'VTL-9.0-Forge',
+  'kimi-k3': 'VTL-10.0-Singularity',
 };
 
-// Older `vierratale-<word>` names, accepted everywhere for backwards
-// compatibility (existing config files may still contain them).
+// Legacy display names (older `VRTL-*` and `vierratale-<word>`), accepted
+// everywhere for backwards compatibility (existing config files may contain
+// them). All map onto the current VTL display names.
 const LEGACY_DISPLAY = {
-  'vierratale-lite': 'VRTL-1.lite',
-  'vierratale-fast': 'VRTL-2.fast',
-  'vierratale-small': 'VRTL-3.small',
-  'vierratale-balanced': 'VRTL-4.balanced',
-  'vierratale-plus': 'VRTL-5.plus',
-  'vierratale-pro': 'VRTL-6.pro',
-  'vierratale-cloud-mini': 'VRTL-7.cloud-mini',
-  'vierratale-cloud': 'VRTL-8.cloud',
-  'vierratale-cloud-fast': 'VRTL-9.cloud-fast',
-  'vierratale-cloud-pro': 'VRTL-10.cloud-pro',
-  'vierratale-cloud-lite': 'VRTL-11.cloud-lite',
-  'vierratale-cloud-plus': 'VRTL-12.cloud-plus',
+  'VRTL-1.lite': 'VTL-2.5-Mini',
+  'VRTL-2.fast': 'VTL-2.7-Flash',
+  'VRTL-3.small': 'VTL-2.9-Core',
+  'VRTL-4.balanced': 'VTL-3.1-Plus',
+  'VRTL-4.coder': 'VTL-3.3-Pro',
+  'VRTL-5.plus': 'VTL-3.5-Reason',
+  'VRTL-6.pro': 'VTL-3.7-Ultra',
+  'VRTL-7.cloud-mini': 'VTL-4.0',
+  'VRTL-8.cloud': 'VTL-4.2-Omni',
+  'VRTL-9.cloud-fast': 'VTL-4.5-Plus',
+  'VRTL-10.cloud-pro': 'VTL-5.0-Pro',
+  'VRTL-11.cloud-lite': 'VTL-6.0-Reason',
+  'VRTL-12.cloud-plus': 'VTL-7.0-Omnij',
+  'vierratale-lite': 'VTL-2.5-Mini',
+  'vierratale-fast': 'VTL-2.7-Flash',
+  'vierratale-small': 'VTL-2.9-Core',
+  'vierratale-balanced': 'VTL-3.1-Plus',
+  'vierratale-plus': 'VTL-3.5-Reason',
+  'vierratale-pro': 'VTL-3.7-Ultra',
+  'vierratale-cloud-mini': 'VTL-4.0',
+  'vierratale-cloud': 'VTL-4.2-Omni',
+  'vierratale-cloud-fast': 'VTL-4.5-Plus',
+  'vierratale-cloud-pro': 'VTL-5.0-Pro',
+  'vierratale-cloud-lite': 'VTL-6.0-Reason',
+  'vierratale-cloud-plus': 'VTL-7.0-Omnij',
 };
 
 const REVERSE = Object.fromEntries(
@@ -38,42 +61,58 @@ const REVERSE = Object.fromEntries(
 );
 
 const LOCAL_MODELS = [
-  'VRTL-1.lite',
-  'VRTL-2.fast',
-  'VRTL-3.small',
-  'VRTL-4.balanced',
-  'VRTL-4.coder',
-  'VRTL-5.plus',
-  'VRTL-6.pro',
+  'VTL-2.5-Mini',
+  'VTL-2.7-Flash',
+  'VTL-2.9-Core',
+  'VTL-3.2-Orbit',
+  'VTL-3.1-Plus',
+  'VTL-3.3-Pro',
+  'VTL-3.5-Reason',
+  'VTL-3.7-Ultra',
+  'VTL-4.7-Gusto',
+  'VTL-5.4-Tempo',
+  'VTL-5.2-Pinnacle',
+  'VTL-5.9-Sovereign',
 ];
 
 const CLOUD_MODELS = [
-  'VRTL-7.cloud-mini',
-  'VRTL-8.cloud',
-  'VRTL-9.cloud-fast',
-  'VRTL-10.cloud-pro',
-  'VRTL-11.cloud-lite',
-  'VRTL-12.cloud-plus',
+  'VTL-4.0',
+  'VTL-4.2-Omni',
+  'VTL-4.5-Plus',
+  'VTL-5.0-Pro',
+  'VTL-6.0-Reason',
+  'VTL-7.0-Omnij',
+  'VTL-8.0-Fabric',
+  'VTL-9.0-Forge',
+  'VTL-10.0-Singularity',
 ];
 
 const TIERS = {
-  'VRTL-1.lite': 'minimal',
-  'VRTL-2.fast': 'fast',
-  'VRTL-3.small': 'small',
-  'VRTL-4.balanced': 'balanced',
-  'VRTL-4.coder': 'coder',
-  'VRTL-5.plus': 'plus',
-  'VRTL-6.pro': 'professional',
-  'VRTL-7.cloud-mini': 'cloud-mini',
-  'VRTL-8.cloud': 'cloud',
-  'VRTL-9.cloud-fast': 'cloud-fast',
-  'VRTL-10.cloud-pro': 'cloud-pro',
-  'VRTL-11.cloud-lite': 'cloud-lite',
-  'VRTL-12.cloud-plus': 'cloud-plus',
+  'VTL-2.5-Mini': 'minimal',
+  'VTL-2.7-Flash': 'fast',
+  'VTL-2.9-Core': 'small',
+  'VTL-3.2-Orbit': 'small',
+  'VTL-3.1-Plus': 'balanced',
+  'VTL-3.3-Pro': 'coder',
+  'VTL-3.5-Reason': 'reasoning',
+  'VTL-3.7-Ultra': 'ultra',
+  'VTL-4.7-Gusto': 'balanced',
+  'VTL-5.4-Tempo': 'balanced',
+  'VTL-5.2-Pinnacle': 'pro',
+  'VTL-5.9-Sovereign': 'pro',
+  'VTL-4.0': 'cloud-mini',
+  'VTL-4.2-Omni': 'cloud',
+  'VTL-4.5-Plus': 'cloud-fast',
+  'VTL-5.0-Pro': 'cloud-pro',
+  'VTL-6.0-Reason': 'cloud-lite',
+  'VTL-7.0-Omnij': 'cloud-plus',
+  'VTL-8.0-Fabric': 'cloud-fabric',
+  'VTL-9.0-Forge': 'cloud-forge',
+  'VTL-10.0-Singularity': 'cloud-singularity',
 };
 
 export const Catalog = {
-  // Map any known name (new or legacy) to the current VRTL display name.
+  // Map any known name (new or legacy) to the current VTL display name.
   normalize(displayName) {
     return LEGACY_DISPLAY[displayName] || displayName;
   },
@@ -99,11 +138,11 @@ export const Catalog = {
   },
 
   getDefaultModel() {
-    return 'VRTL-2.fast';
+    return 'VTL-2.7-Flash';
   },
 
   getDefaultCloudModel() {
-    return 'VRTL-7.cloud-mini';
+    return 'VTL-4.0';
   },
 
   isLocalModel(displayName) {
@@ -136,4 +175,4 @@ export const Catalog = {
       tier: TIERS[name] || 'unknown',
     };
   },
-};
+};

package/src/cli.js

@@ -2,7 +2,7 @@ import { execFile } from 'child_process';
 import { promisify } from 'util';
 import { Config } from './config.js';
 import { Catalog } from './catalog.js';
-import { Installer } from './installer.js';
+import { Engine } from './engine.js';
 import { ProviderFactory } from './providers/index.js';
 import { Branding } from './ui/branding.js';
 import { Terminal } from './ui/terminal.js';
@@ -41,7 +41,7 @@ Usage: vierrataleai [options]
 
 Options:
   --provider, -p <name>   Provider: cortex, openai (default: auto-detect)
-  --model, -m <name>      Model: VRTL-1.lite/2.fast/4.balanced/6.pro/8.cloud
+  --model, -m <name>      Model: e.g. VTL-2.7-Flash/3.5-Reason/6.0-Reason
   --clear                 (deprecated: screen is always cleared on start)
   --install, --setup      Install engine + model + a "vierrataleai" command, then run
   --version, -v           Show version
@@ -811,7 +811,7 @@ async function chat(provider, systemPrompt) {
         : Catalog.getCloudModels();
       const installedSet = new Set();
       if (provider.isLocal) {
-        for (const m of await Installer.getInstalledModels(Config.get('engineHost'))) {
+        for (const m of await Engine.getInstalledModels(Config.get('engineHost'))) {
           installedSet.add(m);
         }
       }
@@ -830,8 +830,8 @@ async function chat(provider, systemPrompt) {
         const extras = [...installedSet].filter(
           (m) => !Catalog.getModelInfo(m) && m !== Config.getEffectiveModel(provider.name)
         );
-        for (const m of extras) {
-          chatUI.notify(`  ${m} ✓ (raw engine model)`);
+        if (extras.length) {
+          chatUI.notify(`  (+${extras.length} additional engine models available)`);
         }
       }
       chatUI.render(messages);
@@ -850,7 +850,7 @@ async function chat(provider, systemPrompt) {
           chatUI.setModel(model, provider.displayName);
         };
         if (provider.isLocal && Catalog.isCloudModel(canonical)) {
-          chatUI.notify(`Cannot use cloud model "${canonical}" on ${provider.displayName} (local). Use /model VRTL-6.pro or /provider openai.`);
+          chatUI.notify(`Cannot use cloud model "${canonical}" on ${provider.displayName} (local). Use /model VTL-3.7-Ultra or /provider openai.`);
         } else if (!info) {
           if (provider.isLocal) {
             const switched = await ensureRawLocalModel(modelName, (m) => chatUI.notify(m));
@@ -993,7 +993,7 @@ async function chat(provider, systemPrompt) {
       const info = Catalog.getModelInfo(model);
       chatUI.clearNotices();
       chatUI.notify(
-        `I'm running on ${model} (${info ? info.realModel : model}) via the ${provider.displayName} engine.`
+        `I'm running on ${model} via the ${provider.displayName} engine.`
       );
       chatUI.render(messages);
       continue;
@@ -1114,18 +1114,18 @@ async function ensureLocalModel(modelName, notify) {
 // dead-ends while at least one local model exists.
 async function ensureRawLocalModel(realModel, notify) {
   const host = Config.get('engineHost');
-  const resolved = await Installer.resolveModel(host, realModel);
+  const resolved = await Engine.resolveModel(host, realModel);
   if (resolved.model) {
     return { ok: true, model: resolved.model, reason: resolved.reason };
   }
   if (notify) notify(`Downloading ${realModel}… (this can take a while)`);
-  const pulled = await Installer.pullModel(host, realModel);
+  const pulled = await Engine.pullModel(host, realModel);
   if (pulled) {
     if (notify) notify(`Model ${realModel} ready.`);
     return { ok: true, model: realModel, reason: null };
   }
   if (notify) notify(`Could not download ${realModel}.`);
-  const first = await Installer.firstInstalled(host);
+  const first = await Engine.firstInstalled(host);
   if (first) {
     return { ok: true, model: first, reason: `Could not download ${realModel}; using installed ${first}` };
   }
@@ -1264,7 +1264,7 @@ export async function run() {
 
   await Terminal.showProgress(
     ['Checking engine', 'Installing dependencies', 'Downloading model', 'Optimizing'],
-    () => Installer.ensure()
+    () => Engine.ensure()
   );
 
   await ensureLocalModel(Config.get('model'));

package/src/config.js

@@ -12,7 +12,7 @@ function configPaths() {
 
 const DEFAULTS = {
   provider: 'auto',
-  model: 'VRTL-2.fast',
+  model: 'VTL-2.7-Flash',
   engineHost: 'http://127.0.0.1:11434',
   numCtx: 2048,
   temperature: 0.7,

package/src/engine.js

@@ -0,0 +1,150 @@
+import { execSync, exec } from 'child_process';
+import { existsSync } from 'fs';
+import { Catalog } from './catalog.js';
+import { Config } from './config.js';
+
+function runSilent(cmd) {
+  return new Promise((resolve) => {
+    exec(cmd, { stdio: 'ignore' }, (err) => resolve(!err));
+  });
+}
+
+function isEngineRunning(host) {
+  return fetch(`${host}/api/tags`, { signal: AbortSignal.timeout(3000) })
+    .then((r) => r.ok)
+    .catch(() => false);
+}
+
+function isEngineInstalled() {
+  try {
+    execSync('which ollama 2>/dev/null', { stdio: 'ignore' });
+    return true;
+  } catch {}
+  const paths = ['/usr/local/bin/ollama', '/usr/bin/ollama'];
+  return paths.some((p) => existsSync(p));
+}
+
+async function installEngine() {
+  await runSilent('curl -fsSL https://ollama.com/install.sh | sh');
+  return isEngineInstalled();
+}
+
+async function getInstalledModels(host) {
+  try {
+    const resp = await fetch(`${host}/api/tags`);
+    if (!resp.ok) return [];
+    const data = await resp.json();
+    return (data.models || []).map((m) => m.name);
+  } catch {
+    return [];
+  }
+}
+
+async function pullModel(host, model) {
+  try {
+    const resp = await fetch(`${host}/api/pull`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name: model, stream: false }),
+      signal: AbortSignal.timeout(600000),
+    });
+    return resp.ok;
+  } catch {
+    return false;
+  }
+}
+
+function familyOf(model) {
+  return model
+    .split(':')[0]
+    .toLowerCase()
+    .replace(/-(coder|instruct|reasoning|chat|base|tiny|nano)$/, '');
+}
+
+function sizeOf(model) {
+  const size = model.split(':')[1] || '';
+  const match = size.match(/(\d+(?:\.\d+)?)(m|b)/i);
+  if (!match) return Number.POSITIVE_INFINITY;
+  const value = parseFloat(match[1]);
+  return match[2].toLowerCase() === 'b' ? value * 1000 : value;
+}
+
+function chooseModel(installed, realModel) {
+  if (installed.includes(realModel)) {
+    return { model: realModel, substituted: false, reason: null };
+  }
+  const fam = familyOf(realModel);
+  let best = null;
+  let bestDist = Number.POSITIVE_INFINITY;
+  for (const m of installed) {
+    if (familyOf(m) !== fam) continue;
+    const dist = Math.abs(sizeOf(m) - sizeOf(realModel)) + 0.5;
+    if (dist < bestDist) {
+      bestDist = dist;
+      best = m;
+    }
+  }
+  if (best) {
+    return {
+      model: best,
+      substituted: true,
+      reason: `"${realModel}" is not installed; using ${best} (same family)`,
+    };
+  }
+  return { model: null, substituted: true, reason: `"${realModel}" is not installed` };
+}
+
+async function resolveModel(host, realModel) {
+  const installed = await getInstalledModels(host);
+  return chooseModel(installed, realModel);
+}
+
+async function ensure() {
+  const host = Config.get('engineHost');
+
+  if (!isEngineInstalled()) {
+    await installEngine();
+  }
+
+  const running = await isEngineRunning(host);
+  if (!running) {
+    try {
+      const child = exec('ollama serve', {
+        stdio: 'ignore',
+        detached: true,
+      });
+      if (child.unref) child.unref();
+      for (let i = 0; i < 30; i++) {
+        await new Promise((r) => setTimeout(r, 1000));
+        if (await isEngineRunning(host)) break;
+      }
+    } catch {}
+  }
+
+  const realModel = Catalog.getRealModel(Config.get('model'));
+  const installed = await getInstalledModels(host);
+  const resolved = chooseModel(installed, realModel);
+  if (resolved.model == null) {
+    await pullModel(host, realModel);
+  }
+
+  return true;
+}
+
+async function isReady() {
+  const host = Config.get('engineHost');
+  return isEngineRunning(host);
+}
+
+export const Engine = {
+  ensure,
+  isReady,
+  pullModel,
+  getInstalledModels,
+  resolveModel,
+  chooseModel,
+  firstInstalled: async (host) => {
+    const installed = await getInstalledModels(host);
+    return installed[0] || null;
+  },
+};

package/src/index.js

@@ -1,6 +1,6 @@
 export { Catalog } from './catalog.js';
 export { Config } from './config.js';
-export { Installer } from './installer.js';
+export { Engine } from './engine.js';
 export { CortexProvider } from './providers/cortex.js';
 export { OpenAIProvider } from './providers/openai.js';
 export { Branding } from './ui/branding.js';

package/src/providers/cortex.js

@@ -285,14 +285,14 @@ export class CortexProvider extends BaseProvider {
 // engine host is deliberately kept out of the message; errors carry codes.
 async function describeEngineError(resp, model) {
   if (/not found|does not exist|model.*missing/i.test(String(resp.statusText))) {
-    return `[ERR-0002] Model "${model}" is not installed on the engine. If you picked a cloud model, use /model VRTL-6.pro or /provider openai.`;
+    return `[ERR-0002] Model "${model}" is not installed on the engine. If you picked a cloud model, use /model VTL-3.7-Ultra or /provider openai.`;
   }
   let body = '';
   try {
     body = (await resp.text()).slice(0, 300);
   } catch {}
   if (/not found|does not exist|model.*missing/i.test(body)) {
-    return `[ERR-0002] Model "${model}" is not installed on the engine. If you picked a cloud model, use /model VRTL-6.pro or /provider openai.`;
+    return `[ERR-0002] Model "${model}" is not installed on the engine. If you picked a cloud model, use /model VTL-3.7-Ultra or /provider openai.`;
   }
-  return `[ERR-0003] The engine returned HTTP ${resp.status}. Check the engine status or run /model VRTL-2.fast.`;
+  return `[ERR-0003] The engine returned HTTP ${resp.status}. Check the engine status or run /model VTL-2.7-Flash.`;
 }

package/src/ui/branding.js

@@ -1,6 +1,6 @@
 export const Branding = {
   APP_NAME: 'VierrataleAI',
-  VERSION: '0.1.0-beta.12',
+  VERSION: '0.1.0-beta.15',
 
   colors: {
     primary: '\x1b[38;2;124;58;237m',

package/src/installer.js

@@ -1,300 +0,0 @@
-import { execSync, exec } from 'child_process';
-import { existsSync, mkdirSync, symlinkSync, chmodSync, writeFileSync, lstatSync, readlinkSync, rmSync, realpathSync } from 'fs';
-import { join, dirname, resolve } from 'path';
-import { fileURLToPath } from 'url';
-import { homedir, platform } from 'os';
-import { Catalog } from './catalog.js';
-import { Config } from './config.js';
-
-function runSilent(cmd) {
-  return new Promise((resolve) => {
-    exec(cmd, { stdio: 'ignore' }, (err) => resolve(!err));
-  });
-}
-
-function isEngineRunning(host) {
-  return fetch(`${host}/api/tags`, { signal: AbortSignal.timeout(3000) })
-    .then((r) => r.ok)
-    .catch(() => false);
-}
-
-function isEngineInstalled() {
-  try {
-    execSync('which ollama 2>/dev/null', { stdio: 'ignore' });
-    return true;
-  } catch {}
-  const paths = ['/usr/local/bin/ollama', '/usr/bin/ollama'];
-  return paths.some((p) => existsSync(p));
-}
-
-async function installEngine() {
-  await runSilent('curl -fsSL https://ollama.com/install.sh | sh');
-  return isEngineInstalled();
-}
-
-async function pullModel(host, model) {
-  try {
-    const resp = await fetch(`${host}/api/pull`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ name: model, stream: false }),
-      signal: AbortSignal.timeout(600000),
-    });
-    return resp.ok;
-  } catch {
-    return false;
-  }
-}
-
-async function getInstalledModels(host) {
-  try {
-    const resp = await fetch(`${host}/api/tags`);
-    if (!resp.ok) return [];
-    const data = await resp.json();
-    return (data.models || []).map((m) => m.name);
-  } catch {
-    return [];
-  }
-}
-
-// Scripts in the same model family share a base name before any variant
-// suffix (e.g. qwen2.5-coder:1.5b is the sibling of qwen2.5:1.5b).
-function familyOf(model) {
-  return model
-    .split(':')[0]
-    .toLowerCase()
-    .replace(/-(coder|instruct|reasoning|chat|base|tiny|nano)$/, '');
-}
-
-function sizeOf(model) {
-  const size = model.split(':')[1] || '';
-  const match = size.match(/(\d+(?:\.\d+)?)(m|b)/i);
-  if (!match) return Number.POSITIVE_INFINITY;
-  const value = parseFloat(match[1]);
-  return match[2].toLowerCase() === 'b' ? value * 1000 : value;
-}
-
-// Find the already-installed model that best matches the requested one.
-// Prefers an exact match, then any same-family sibling (closest size).
-function chooseModel(installed, realModel) {
-  if (installed.includes(realModel)) {
-    return { model: realModel, substituted: false, reason: null };
-  }
-  const fam = familyOf(realModel);
-  let best = null;
-  let bestDist = Number.POSITIVE_INFINITY;
-  for (const m of installed) {
-    if (familyOf(m) !== fam) continue;
-    const dist = Math.abs(sizeOf(m) - sizeOf(realModel)) + 0.5;
-    if (dist < bestDist) {
-      bestDist = dist;
-      best = m;
-    }
-  }
-  if (best) {
-    return {
-      model: best,
-      substituted: true,
-      reason: `"${realModel}" is not installed; using ${best} (same family)`,
-    };
-  }
-  return { model: null, substituted: true, reason: `"${realModel}" is not installed` };
-}
-
-async function resolveModel(host, realModel) {
-  const installed = await getInstalledModels(host);
-  return chooseModel(installed, realModel);
-}
-
-// Best local bin dir for a globally-callable command on this platform.
-function localBinDir() {
-  if (process.env.XDG_BIN_HOME) return process.env.XDG_BIN_HOME;
-  if (process.env.HOME) return join(homedir(), '.local', 'bin');
-  return '/usr/local/bin';
-}
-
-function isOnPath(dir) {
-  const sep = platform() === 'win32' ? ';' : ':';
-  let dirResolved;
-  try {
-    dirResolved = existsSync(dir) ? realpathSync(dir) : resolve(dir);
-  } catch {
-    dirResolved = resolve(dir);
-  }
-  return String(process.env.PATH || '')
-    .split(sep)
-    .some((entry) => {
-      entry = entry.trim();
-      if (!entry) return false;
-      try {
-        const e = existsSync(entry) ? realpathSync(entry) : resolve(entry);
-        return e === dirResolved;
-      } catch {
-        return false;
-      }
-    });
-}
-
-// Prefer a bin dir that is already on PATH (and writable) so the installed
-// command is callable immediately; fall back to the local bin dir.
-function chooseBinDir() {
-  const local = localBinDir();
-  if (isOnPath(local)) return local;
-  for (const candidate of ['/usr/local/bin', '/usr/bin']) {
-    try {
-      mkdirSync(candidate, { recursive: true, mode: 0o755 });
-      const probe = join(candidate, `.vierrataleai-write-test-${process.pid}`);
-      writeFileSync(probe, '');
-      rmSync(probe, { force: true });
-      return candidate;
-    } catch {}
-  }
-  return local;
-}
-
-// Create (or refresh) a launcher link for `name` pointing at the node bin.
-function writeLauncher(dir, name, target) {
-  const launcherPath = join(dir, name);
-  if (platform() === 'win32') {
-    if (!existsSync(launcherPath)) {
-      writeFileSync(launcherPath, `@echo off\r\nnode "${target}" %*\r\n`);
-    }
-    return launcherPath;
-  }
-  // Prefer a real symlink; fall back to a small shim that calls the node bin.
-  let live = false;
-  try {
-    live = lstatSync(launcherPath).isSymbolicLink() && readlinkSync(launcherPath) === target;
-  } catch {}
-  if (!live) {
-    rmSync(launcherPath, { force: true });
-    try {
-      symlinkSync(target, launcherPath);
-      chmodSync(launcherPath, 0o755);
-    } catch {
-      writeFileSync(launcherPath, `#!/bin/sh\nnode "${target}" "$@"\n`);
-      chmodSync(launcherPath, 0o755);
-    }
-  }
-  return launcherPath;
-}
-
-function installAppCommand() {
-  try {
-    const dir = chooseBinDir();
-    mkdirSync(dir, { recursive: true, mode: 0o755 });
-    const defaultTarget = join(dirname(fileURLToPath(import.meta.url)), '..', 'bin', 'vierrataleai.js');
-    const target = process.argv[1] && existsSync(process.argv[1]) ? process.argv[1] : defaultTarget;
-    // Both spellings run the assistant.
-    const launcherPath = writeLauncher(dir, 'vierrataleai', target);
-    writeLauncher(dir, 'vierratale', target);
-    return launcherPath;
-  } catch {
-    return null;
-  }
-}
-
-export const Installer = {
-  async pullModel(host, model) {
-    return pullModel(host, model);
-  },
-
-  async getInstalledModels(host) {
-    return getInstalledModels(host);
-  },
-
-  async resolveModel(host, realModel) {
-    return resolveModel(host, realModel);
-  },
-
-  async firstInstalled(host) {
-    const installed = await getInstalledModels(host);
-    return installed[0] || null;
-  },
-
-  chooseModel,
-
-  installAppCommand,
-  isOnPath,
-
-  async ensure() {
-    const host = Config.get('engineHost');
-
-    if (!isEngineInstalled()) {
-      await installEngine();
-    }
-
-    const running = await isEngineRunning(host);
-    if (!running) {
-      try {
-        // No systemd available here, so launch the daemon directly, detached,
-        // and poll until it responds instead of relying on a service manager.
-        const child = exec('ollama serve', {
-          stdio: 'ignore',
-          detached: true,
-        });
-        if (child.unref) child.unref();
-        for (let i = 0; i < 30; i++) {
-          await new Promise((r) => setTimeout(r, 1000));
-          if (await isEngineRunning(host)) break;
-        }
-      } catch {}
-    }
-
-    const realModel = Catalog.getRealModel(Config.get('model'));
-    const installed = await getInstalledModels(host);
-    const resolved = chooseModel(installed, realModel);
-    const needsPull = resolved.model == null;
-
-    if (needsPull) {
-      await pullModel(host, realModel);
-    }
-
-    return true;
-  },
-
-  async isReady() {
-    const host = Config.get('engineHost');
-    return isEngineRunning(host);
-  },
-
-  // Full install: engine + model + a global "vierrataleai" command.
-  async install({ includeCommand = true } = {}) {
-    const host = Config.get('engineHost');
-
-    if (!isEngineInstalled()) {
-      await installEngine();
-    }
-
-    const running = await isEngineRunning(host);
-    if (!running) {
-      try {
-        const child = exec('ollama serve', { stdio: 'ignore', detached: true });
-        if (child.unref) child.unref();
-        for (let i = 0; i < 30; i++) {
-          await new Promise((r) => setTimeout(r, 1000));
-          if (await isEngineRunning(host)) break;
-        }
-      } catch {}
-    }
-
-    const realModel = Catalog.getRealModel(Config.get('model'));
-    const installed = await getInstalledModels(host);
-    const resolved = chooseModel(installed, realModel);
-    if (resolved.model == null) {
-      await pullModel(host, realModel);
-    }
-
-    let command = null;
-    let commandAlias = null;
-    let commandOnPath = false;
-    if (includeCommand) {
-      command = installAppCommand();
-      if (command) {
-        commandAlias = join(dirname(command), 'vierratale');
-        commandOnPath = isOnPath(dirname(command));
-      }
-    }
-    return { installed: await isEngineInstalled(), running: await isEngineRunning(host), command, commandAlias, commandOnPath };
-  },
-};