offgrid-ai 0.16.3 → 0.18.0

package/src/model-presenters.mjs

@@ -1,23 +1,20 @@
 import { existsSync, statSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
+import { stripVTControlCharacters } from "node:util";
 import { backendFor } from "./backends.mjs";
 import { computeServerCommand, buildStartScript, isProfileRunning } from "./process.mjs";
 import { profileDir } from "./profiles.mjs";
 import { pc, formatBytes, renderSectionRows } from "./ui.mjs";
 import { capabilitySummary, ggufDetailParts, isProfileFileMissing, profileDetailParts } from "./model-summary.mjs";
 import { itemKey } from "./model-catalog.mjs";
-import { DATA_DIR } from "./config.mjs";
-import { findBenchmarkRepo } from "./benchmark.mjs";
 
-const OPTION_SEPARATOR = pc.dim("  │  ");
+const OPTION_SEPARATOR = "  ";
 const OPTION_STATUS_WIDTH = 12;
 const OPTION_BACKEND_WIDTH = 14;
 const OPTION_SOURCE_WIDTH = 14;
 const OPTION_QUANT_WIDTH = 10;
 const OPTION_CTX_WIDTH = 5;
 
-const { stripVTControlCharacters } = await import("node:util");
-
 function optionPad(text, color, width) {
   const visible = stripVTControlCharacters(String(text)).length;
   const padding = Math.max(1, width - visible);
@@ -198,35 +195,6 @@ export function inferBackendId(item) {
   return "llama-cpp";
 }
 
-export function printWorkspaceHeader(normalized, runningProfilesNow, modelMissingIds = new Set()) {
-  const profiles = normalized.profiles;
-  const isRunning = (p) => runningProfilesNow.some((r) => r.id === p.id);
-  const isMissing = (p) => isProfileFileMissing(p) || modelMissingIds.has(p.id);
-  const readyCount = profiles.filter((p) => !isMissing(p) && !isRunning(p)).length;
-  const runningCount = runningProfilesNow.length;
-  const missingCount = profiles.filter(isMissing).length;
-  const setupCount = normalized.newModels.length + normalized.managedItems.length;
-
-  const countParts = [];
-  if (runningCount > 0) countParts.push(pc.green(`${runningCount} running`));
-  if (readyCount > 0) countParts.push(pc.blue(`${readyCount} model${readyCount === 1 ? "" : "s"} ready`));
-  if (missingCount > 0) countParts.push(pc.red(`${missingCount} model${missingCount === 1 ? "" : "s"} missing`));
-  if (setupCount > 0) countParts.push(pc.yellow(`${setupCount} model${setupCount === 1 ? "" : "s"} need${setupCount === 1 ? "s" : ""} setup`));
-
-  console.log(`   ${countParts.join(pc.dim(" · "))}`);
-  console.log(pc.dim(`   Profiles: ${DATA_DIR}`));
-  console.log(pc.dim("   ─────────────────────────────────────────────────────────"));
-}
-
-export async function printBenchmarkLine() {
-  const repoPath = await findBenchmarkRepo();
-  if (repoPath) {
-    console.log(pc.green("   ✓") + " local-llm-visual-benchmark linked");
-  } else {
-    console.log(pc.yellow("   ○") + " to run benchmarks, pair with " + pc.cyan("local-llm-visual-benchmark"));
-  }
-}
-
 export async function printProfileDetails(profile) {
   const backend = backendFor(profile.backend);
   const isManaged = backend.type === "managed-server";
@@ -266,8 +234,9 @@ export async function printProfileDetails(profile) {
       const scriptPath = join(profileDir(profile.id), "start.sh");
       console.log("\n" + renderSectionRows("Server command", [
         ["Run manually", pc.cyan(`bash ${scriptPath}`)],
-        ["Command", pc.dim(script)],
-      ], { columns: Math.min(process.stdout.columns ?? 120, 140) }));
+      ]));
+      console.log("");
+      console.log(pc.dim(script));
     }
   }
 }

package/src/model-summary.mjs

@@ -23,7 +23,7 @@ export function capabilitySummary(caps) {
   return parts.length > 0 ? parts.join(" · ") : "standard GGUF";
 }
 
-export function profileMtpLabel(profile, drafters, { detailed = false } = {}) {
+function profileMtpLabel(profile, drafters, { detailed = false } = {}) {
   if (profile.drafterPath) {
     return detailed ? pc.green(`MTP enabled (drafter: ${basename(profile.drafterPath)})`) : pc.green("MTP enabled");
   }
@@ -34,7 +34,7 @@ export function profileMtpLabel(profile, drafters, { detailed = false } = {}) {
   return null;
 }
 
-export function ggufMtpLabel(model, drafter) {
+function ggufMtpLabel(model, drafter) {
   const caps = detectCapabilities(model.path, model.mmprojPath);
   if (caps.mtp || Boolean(drafter)) return pc.green("MTP ✓");
   if (caps.architecture === "gemma4") return pc.yellow("MTP: needs drafter");

package/src/omlx-runtime.mjs

@@ -14,7 +14,7 @@ import { join } from "node:path";
 import { promisify } from "node:util";
 import { compareVersions } from "./updates.mjs";
 import { hasHomebrew, ensureHomebrewFor } from "./config.mjs";
-import { commandExists } from "./exec.mjs";
+import { commandExists, runCommand } from "./exec.mjs";
 import { pc, renderCard, renderRows } from "./ui.mjs";
 
 const execFileAsync = promisify(execFile);
@@ -138,7 +138,6 @@ export async function offerManagedOmlxUpdate(prompt, { fetchImpl = globalThis.fe
   if (!shouldUpdate) return false;
 
   try {
-    const { runCommand } = await import("./exec.mjs");
     console.log(pc.dim("Updating oMLX via Homebrew..."));
     await runCommand("brew", ["update"], { label: "brew update" });
     await runCommand("brew", ["upgrade", "omlx"], { label: "brew upgrade omlx" });
@@ -153,6 +152,34 @@ export async function offerManagedOmlxUpdate(prompt, { fetchImpl = globalThis.fe
 
 // ── Installation ───────────────────────────────────────────────────────────
 
+/**
+ * Offer to restart oMLX so it picks up new or deleted models.
+ * @param {object} prompt - UI prompt interface (yesNo)
+ * @param {string} [reason] - why we're restarting (e.g. "to load the new model")
+ * @returns {Promise<boolean>} true if oMLX was restarted
+ */
+export async function offerOmlxRestart(prompt, reason = "to update its model list") {
+  const bin = await findOmlx();
+  if (!bin) {
+    console.log(pc.dim("Restart oMLX manually: omlx restart"));
+    return false;
+  }
+  const shouldRestart = await prompt.yesNo(`Restart oMLX ${reason}?`, true);
+  if (!shouldRestart) {
+    console.log(pc.dim("Restart manually later: omlx restart"));
+    return false;
+  }
+  try {
+    await execFileAsync(bin, ["restart"], { timeout: 15000 });
+    console.log(pc.green("✓ oMLX restarted"));
+    return true;
+  } catch (err) {
+    console.log(pc.red(`✗ Restart failed: ${err.message}`));
+    console.log(pc.dim("Restart manually: omlx restart"));
+    return false;
+  }
+}
+
 /**
  * Install oMLX. Uses Homebrew if available (automating tap + install).
  * If Homebrew is not available, prompts to download the DMG from GitHub
@@ -167,7 +194,6 @@ export async function installOmlx(prompt, run) {
 
   if (!hasBrew) {
     if (!(await ensureHomebrewFor(prompt, run || (async (cmd, args, label) => {
-      const { runCommand } = await import("./exec.mjs");
       return runCommand(cmd, args, { label });
     }), "oMLX"))) {
       console.log(pc.dim("Install oMLX manually:"));
@@ -179,7 +205,6 @@ export async function installOmlx(prompt, run) {
 
   // Install oMLX via Homebrew
   const runner = run || (async (cmd, args, label) => {
-    const { runCommand } = await import("./exec.mjs");
     return runCommand(cmd, args, { label });
   });
 

package/src/process.mjs

@@ -6,6 +6,8 @@ import { basename, join } from "node:path";
 import { LOG_DIR } from "./config.mjs";
 import { writeState, readState, profileDir } from "./profiles.mjs";
 import { backendFor, backendBinaryFor } from "./backends.mjs";
+import { computeFlags } from "./autodetect.mjs";
+import { findOmlx } from "./omlx-runtime.mjs";
 import { pc } from "./ui.mjs";
 
 const execFileAsync = promisify(execFile);
@@ -23,7 +25,6 @@ export async function computeServerCommand(profile) {
   if (!binary) throw new Error("Server binary not found. Run offgrid-ai interactively to install.");
 
   // llama-cpp
-  const { computeFlags } = await import("./autodetect.mjs");
   const result = computeFlags(
     profile.capabilities ?? {},
     profile.modelPath,
@@ -129,14 +130,11 @@ async function startManagedServer(profile, backend) {
   // Try to start the managed server via CLI
   if (backend.id === "omlx") {
     try {
-      const { execFile } = await import("node:child_process");
-      const { promisify } = await import("node:util");
-      const { findOmlx } = await import("./omlx-runtime.mjs");
       const omlxBin = await findOmlx();
       if (!omlxBin) {
         throw new Error(`${backend.label} is not installed. Run offgrid-ai to install it, or install manually: brew tap jundot/omlx && brew install omlx`);
       }
-      await promisify(execFile)(omlxBin, ["start"], { timeout: 10000 });
+      await execFileAsync(omlxBin, ["start"], { timeout: 10000 });
     } catch (err) {
       if (err.message.includes("not installed")) throw err;
       throw new Error(`${backend.label} could not be auto-started: ${err.message}. Run \`omlx start\` manually.`, { cause: err });

package/src/profile-setup.mjs

@@ -14,12 +14,28 @@ import { detectOmlxMtpCapability, findOmlxModelDir } from "./mlx-discovery.mjs";
 const execFileAsync = promisify(execFile);
 
 const CACHE_CHOICES = [
-  { value: "bf16", label: "bf16", hint: "default: stable, good quality" },
-  { value: "f16", label: "f16", hint: "stable fallback, similar memory to bf16" },
-  { value: "q8_0", label: "q8_0", hint: "lower memory, usually safe" },
-  { value: "q4_0", label: "q4_0", hint: "lowest memory, quality/speed tradeoff" },
+  { value: "bf16", label: "bf16", hint: "16-bit · best quality · 2 bytes/elem" },
+  { value: "f16", label: "f16", hint: "16-bit · stable fallback · 2 bytes/elem" },
+  { value: "q8_0", label: "q8_0", hint: "8-bit · half memory · usually safe · 1 byte/elem" },
+  { value: "q4_0", label: "q4_0", hint: "4-bit · quarter memory · quality tradeoff · 0.5 bytes/elem" },
 ];
 
+function quickKvBytes(modelPath, flags) {
+  try {
+    return estimateMemory(modelPath, null, null, flags).kvBytes;
+  } catch {
+    return 0;
+  }
+}
+
+function cacheMemoryRows(modelPath, flags, ctxSize) {
+  const combos = [["bf16", "bf16"], ["f16", "f16"], ["q8_0", "q8_0"], ["q4_0", "q4_0"]];
+  return combos.map(([k, v]) => {
+    const bytes = quickKvBytes(modelPath, { ...flags, ctxSize, cacheTypeK: k, cacheTypeV: v });
+    return [`${k}/${v} KV cache`, bytes ? `~${formatBytes(bytes)}` : "unknown"];
+  });
+}
+
 const GENERAL_DEFAULTS = {
   topK: 20,
   presencePenalty: 1.5,
@@ -40,7 +56,6 @@ export async function configureLocalProfile(prompt, profile) {
   const freshCaps = detectCapabilities(profile.modelPath, profile.mmprojPath);
   let drafterPath = profile.drafterPath ?? null;
   if (drafterPath && !existsSync(drafterPath)) {
-    // Stored drafter is no longer on disk — drop it and re-scan for a fresh one.
     drafterPath = null;
   }
   if (!drafterPath) {
@@ -50,86 +65,229 @@ export async function configureLocalProfile(prompt, profile) {
   }
   const hasMtp = freshCaps.mtp || Boolean(drafterPath);
   const caps = { ...freshCaps, mtp: hasMtp };
-  // MTP is a capability, not a separate backend. Just update the profile's
-  // capabilities and drafter path — flag computation handles the rest.
   configured = { ...configured, drafterPath: drafterPath ?? null, capabilities: { ...configured.capabilities, mtp: hasMtp } };
-  // If vision was previously disabled but mmproj is back, re-enable
   if (configured.disabledMmprojPath && configured.mmprojPath === null && freshCaps.vision) {
     configured = { ...configured, mmprojPath: configured.disabledMmprojPath, disabledMmprojPath: undefined, capabilities: { ...configured.capabilities, vision: true, visionDisabledReason: undefined } };
   }
 
+  // ── Model overview ──────────────────────────────────────────────────────
   console.log("");
-  console.log(renderSection("Model setup", renderRows([
+  console.log(renderSection("Model overview", renderRows([
     ["Model", pc.bold(profile.label)],
     ["Detected", capabilitySummary(caps)],
-    ["Context", `${profile.flags.ctxSize.toLocaleString()} tokens`],
-    ["KV cache", `${profile.flags.cacheTypeK}/${profile.flags.cacheTypeV}`],
-    ["Sampling", samplingSummary(profile.flags)],
+    ["Backend", "llama.cpp (local server)"],
+    ["Model file", profile.modelPath],
   ])));
-  console.log(pc.dim("Larger context windows use more memory. KV cache precision controls memory used by attention history."));
-  console.log(pc.dim("Sampling defaults are shown for transparency; you can edit the profile later if needed.\n"));
 
+  // ── MTP ────────────────────────────────────────────────────────────────
   if (caps.mtp) {
-    const drafterInfo = configured.drafterPath ? `\n  Drafter: ${configured.drafterPath}` : "";
-    console.log(renderSection("MTP detected", renderRows([
-      ["Feature", "Multi-Token Prediction (speculative decoding)"],
-      ["Flags", `--spec-type draft-mtp --spec-draft-n-max 4${configured.drafterPath ? " --spec-draft-model <drafter>" : ""}`],
-    ])));
-    if (drafterInfo) console.log(pc.dim(drafterInfo));
-    const useMtp = await prompt.yesNo("Use MTP speculative decoding?", true);
-    configured = useMtp ? applyMtpDefaults(configured) : removeMtpDefaults(configured);
-  }
-
-  if (caps.qat) {
     console.log("");
-    console.log(renderSection("QAT detected", renderRows([
-      ["Meaning", "quantization-aware trained"],
-      ["Runtime flags", "none QAT-specific"],
+    console.log(renderSection("MTP (Multi-Token Prediction)", renderRows([
+      ["What it does", "Speculative decoding — predicts multiple tokens at once, verifies them"],
+      ["Speed", "1.5–3x faster generation"],
+      ["Quality", "No loss — rejected predictions fall back to normal"],
+      ["Memory", "Slightly more for draft model weights"],
+      ["Flags", "--spec-type draft-mtp --spec-draft-n-max 4"],
+      ...(configured.drafterPath ? [["Drafter", configured.drafterPath]] : []),
     ])));
+    const useMtp = await prompt.yesNo("Enable MTP speculative decoding?", true);
+    configured = useMtp ? applyMtpDefaults(configured) : removeMtpDefaults(configured);
   }
 
+  // ── Vision ─────────────────────────────────────────────────────────────
   if (caps.vision && profile.mmprojPath) {
     console.log("");
     const gemma4Unified = isGemma4UnifiedProjector(caps.mmprojProjectorType);
     const supported = !gemma4Unified || await runtimeSupportsGemma4Unified();
-    console.log(renderSection("Vision projector detected", renderRows([
-      ["Projector", caps.mmprojProjectorType ?? "unknown"],
+    console.log(renderSection("Vision projector", renderRows([
+      ["What it does", "Enables image understanding — model can see and reason about images"],
+      ["Projector type", caps.mmprojProjectorType ?? "unknown"],
       ["Flag", `--mmproj ${profile.mmprojPath}`],
+      ["Memory", "~200 MB for projector weights (varies by model)"],
       ...(gemma4Unified && !supported ? [["Note", pc.yellow("Gemma 4 unified projectors need llama.cpp b9549+.")]] : []),
     ])));
-    const useVision = await prompt.yesNo("Enable vision with --mmproj?", supported);
+    const useVision = await prompt.yesNo("Enable vision?", supported);
     configured = useVision ? applyVisionDefaults(configured) : removeVisionDefaults(configured, gemma4Unified && !supported ? "gemma4-unified-unsupported" : "user-disabled");
   }
 
+  // ── Thinking ───────────────────────────────────────────────────────────
   if (caps.thinking) {
     console.log("");
-    console.log(renderSection("Thinking model detected", renderRows([
-      ["Defaults", "thinking / loop-safe"],
-      ["Flags", "--top-k 64 --presence-penalty 0 --repeat-penalty 1.1"],
+    console.log(renderSection("Thinking mode", renderRows([
+      ["What it does", "Model reasons step-by-step before answering"],
+      ["Benefit", "Better results for math, code, logic — but slower (more output tokens)"],
+      ["Sampling changes", "top-k → 64, presence penalty → 0, repeat penalty → 1.1 (adjustable below)"],
       ["Template", "--chat-template-kwargs { enable_thinking: true }"],
     ])));
-    const useThinking = await prompt.yesNo("Use these thinking/loop-safe defaults?", true);
+    const useThinking = await prompt.yesNo("Use thinking/loop-safe defaults?", true);
     configured = useThinking ? applyThinkingDefaults(configured) : removeThinkingDefaults(configured);
   }
 
-  const ctxSize = await prompt.number("Context window tokens", configured.flags.ctxSize, 1024, 1048576);
+  // ── Context window ─────────────────────────────────────────────────────
+  const maxCtx = caps.metaCtx ?? 1048576;
+  console.log("");
+  console.log(renderSection("Context window", renderRows([
+    ["What it does", "Maximum tokens the model can process at once (prompt + response + history)"],
+    ["Range", `1,024 – ${maxCtx.toLocaleString()} tokens`],
+    ["Memory", "KV cache grows linearly — larger context = more RAM"],
+    ["Guidance", "8k–32k: chat · 32k–80k: coding/long convos · 128k+: long documents"],
+    ["Model max", `${maxCtx.toLocaleString()} tokens`],
+    ["Default", `${configured.flags.ctxSize.toLocaleString()} tokens`],
+  ])));
+  const ctxSize = await prompt.number("Context window tokens", configured.flags.ctxSize, 1024, maxCtx);
+  configured = applyRuntimeFlagOverrides(configured, { ctxSize });
+
+  // ── K cache precision ──────────────────────────────────────────────────
+  console.log("");
+  console.log(renderSection("K cache precision", renderRows([
+    ["What it is", "KV cache stores attention 'keys' — previous token states used for prediction"],
+    ["Tradeoff", "Lower precision = less memory, potential quality loss"],
+    ...cacheMemoryRows(profile.modelPath, configured.flags, ctxSize),
+  ])));
   const cacheTypeK = await prompt.choice("K cache precision", CACHE_CHOICES, configured.flags.cacheTypeK);
+  configured = applyRuntimeFlagOverrides(configured, { cacheTypeK });
+
+  // ── V cache precision ──────────────────────────────────────────────────
+  console.log("");
+  console.log(renderSection("V cache precision", renderRows([
+    ["What it is", "KV cache stores attention 'values' — token representations from previous layers"],
+    ["Tradeoff", "Same as K cache. Some models are more sensitive to V precision than K"],
+    ...cacheMemoryRows(profile.modelPath, configured.flags, ctxSize),
+  ])));
   const cacheTypeV = await prompt.choice("V cache precision", CACHE_CHOICES, configured.flags.cacheTypeV);
-  configured = applyRuntimeFlagOverrides(configured, { ctxSize, cacheTypeK, cacheTypeV });
+  configured = applyRuntimeFlagOverrides(configured, { cacheTypeV });
+
+  // ── Memory estimate (with chosen context + cache) ──────────────────────
+  console.log("");
+  console.log(renderMemoryEstimate(configured));
+
+  // ── Temperature ────────────────────────────────────────────────────────
+  console.log("");
+  console.log(renderSection("Temperature", renderRows([
+    ["What it does", "Controls randomness in token selection"],
+    ["Range", "0.0 – 2.0"],
+    ["0.0", "Deterministic — always picks most likely token"],
+    ["0.6", "Balanced — default for most models"],
+    ["1.0+", "Creative — more random, may hallucinate"],
+    ["Guidance", "0–0.3: coding/factual · 0.4–0.8: chat · 0.9+: creative writing"],
+  ])));
+  const temperature = await prompt.number("Temperature", configured.flags.temperature, 0, 2, { float: true });
+  configured = applyRuntimeFlagOverrides(configured, { temperature });
+
+  // ── Top-p ──────────────────────────────────────────────────────────────
+  console.log("");
+  console.log(renderSection("Top-p (nucleus sampling)", renderRows([
+    ["What it does", "Only considers tokens in the top p fraction of probability mass"],
+    ["Range", "0.0 – 1.0 (1.0 = consider all tokens)"],
+    ["Guidance", "0.9–0.95: good default · Lower = more focused · Higher = more diverse"],
+  ])));
+  const topP = await prompt.number("Top-p", configured.flags.topP, 0, 1, { float: true });
+  configured = applyRuntimeFlagOverrides(configured, { topP });
+
+  // ── Top-k ──────────────────────────────────────────────────────────────
+  console.log("");
+  console.log(renderSection("Top-k", renderRows([
+    ["What it does", "Limits token selection to top K most likely tokens at each step"],
+    ["Range", "0 – 1000 (0 = disabled, uses top-p instead)"],
+    ["Guidance", "20: general chat · 40–64: thinking/reasoning · 0: rely on top-p"],
+  ])));
+  const topK = await prompt.number("Top-k", configured.flags.topK, 0, 1000);
+  configured = applyRuntimeFlagOverrides(configured, { topK });
+
+  // ── Min-p ──────────────────────────────────────────────────────────────
+  console.log("");
+  console.log(renderSection("Min-p", renderRows([
+    ["What it does", "Excludes tokens with probability below this threshold"],
+    ["Range", "0.0 – 1.0 (0 = disabled)"],
+    ["Guidance", "0: off (default) · 0.05–0.1: reduces hallucination while keeping creativity"],
+  ])));
+  const minP = await prompt.number("Min-p", configured.flags.minP, 0, 1, { float: true });
+  configured = applyRuntimeFlagOverrides(configured, { minP });
+
+  // ── Presence penalty ───────────────────────────────────────────────────
+  console.log("");
+  console.log(renderSection("Presence penalty", renderRows([
+    ["What it does", "Discourages repeated tokens — each used token gets a fixed logit penalty"],
+    ["Range", "0.0 – 2.0 (0 = off)"],
+    ["Guidance", "0: thinking/reasoning · 1.0–1.5: general chat · Too high = incoherent"],
+  ])));
+  const presencePenalty = await prompt.number("Presence penalty", configured.flags.presencePenalty, 0, 2, { float: true });
+  configured = applyRuntimeFlagOverrides(configured, { presencePenalty });
+
+  // ── Repeat penalty ─────────────────────────────────────────────────────
+  console.log("");
+  console.log(renderSection("Repeat penalty", renderRows([
+    ["What it does", "Multiplies probability of repeated tokens (multiplicative, vs presence's additive)"],
+    ["Range", "0.0 – 2.0 (1.0 = no effect)"],
+    ["Guidance", "1.0–1.1: most use cases · Higher = aggressive anti-repeat · Can break code patterns"],
+  ])));
+  const repeatPenalty = await prompt.number("Repeat penalty", configured.flags.repeatPenalty, 0, 2, { float: true });
+  configured = applyRuntimeFlagOverrides(configured, { repeatPenalty });
+
+  // ── Batch size ─────────────────────────────────────────────────────────
+  console.log("");
+  console.log(renderSection("Batch size", renderRows([
+    ["What it does", "Tokens processed in parallel during prompt processing (before generation)"],
+    ["Range", "1 – 4096"],
+    ["Guidance", "512: good default · 2048+: faster for long prompts · Lower if memory tight"],
+  ])));
+  const batchSize = await prompt.number("Batch size", configured.flags.batchSize, 1, 4096);
+  configured = applyRuntimeFlagOverrides(configured, { batchSize });
+
+  // ── Parallel slots ─────────────────────────────────────────────────────
+  console.log("");
+  console.log(renderSection("Parallel slots", renderRows([
+    ["What it does", "Number of concurrent request slots (each handles an independent conversation)"],
+    ["Range", "1 – 10"],
+    ["Memory", "KV cache is multiplied by this number"],
+    ["Guidance", "1: single-user local · 2+: multiple clients connecting simultaneously"],
+  ])));
+  const parallel = await prompt.number("Parallel slots", configured.flags.parallel, 1, 10);
+  configured = applyRuntimeFlagOverrides(configured, { parallel });
+
+  // ── Flash attention ────────────────────────────────────────────────────
+  console.log("");
+  console.log(renderSection("Flash attention", renderRows([
+    ["What it does", "Memory-efficient attention algorithm — faster and less RAM than standard"],
+    ["Guidance", "Always on for modern hardware · Turn off only for old GPU driver compat issues"],
+  ])));
+  const flashAttn = await prompt.yesNo("Enable flash attention?", true);
+  configured = applyRuntimeFlagOverrides(configured, { flashAttention: flashAttn ? "on" : "off" });
+
+  // ── Jinja templates ────────────────────────────────────────────────────
+  console.log("");
+  console.log(renderSection("Jinja chat templates", renderRows([
+    ["What it does", "Enables Jinja2 template rendering for proper chat formatting"],
+    ["Guidance", "Always on for modern models · Turn off only for very old models without chat templates"],
+  ])));
+  const jinja = await prompt.yesNo("Enable Jinja templates?", true);
+  configured = applyRuntimeFlagOverrides(configured, { jinja });
 
+  // ── Final summary ──────────────────────────────────────────────────────
   console.log("");
-  console.log(renderSection("Defaults", renderRows([
+  console.log(renderSection("Configuration summary", renderRows([
+    ["Model", pc.bold(configured.label)],
     ["Backend", configured.backend],
     ["Endpoint", configured.baseUrl],
-    ["Temperature", configured.flags.temperature],
-    ["Top-p", configured.flags.topP],
-    ["Top-k", configured.flags.topK],
-    ["Min-p", configured.flags.minP],
-    ["Presence penalty", configured.flags.presencePenalty],
-    ["Repeat penalty", configured.flags.repeatPenalty],
+    ["Context", `${configured.flags.ctxSize.toLocaleString()} tokens`],
+    ["KV cache", `${configured.flags.cacheTypeK}/${configured.flags.cacheTypeV}`],
+    ["Temperature", String(configured.flags.temperature)],
+    ["Top-p", String(configured.flags.topP)],
+    ["Top-k", String(configured.flags.topK)],
+    ["Min-p", String(configured.flags.minP)],
+    ["Presence penalty", String(configured.flags.presencePenalty)],
+    ["Repeat penalty", String(configured.flags.repeatPenalty)],
+    ["Batch size", String(configured.flags.batchSize)],
+    ["Parallel", String(configured.flags.parallel)],
+    ["Flash attention", configured.flags.flashAttention],
+    ["Jinja", configured.flags.jinja ? "on" : "off"],
+    ...(configured.capabilities?.mtp ? [["MTP", "enabled"]] : []),
+    ...(configured.capabilities?.vision ? [["Vision", "enabled"]] : []),
+    ...(configured.capabilities?.thinking ? [["Thinking", "enabled"]] : []),
   ])));
 
-  console.log("\n" + renderMemoryEstimate(configured));
+  console.log("");
+  console.log(renderMemoryEstimate(configured));
   if (!(await prompt.yesNo("Save profile with these settings?", true))) return null;
   return configured;
 }
@@ -240,10 +398,12 @@ function applyProfileFlags(profile, flags) {
 
 function renderMemoryEstimate(profile) {
   try {
-    const est = estimateMemory(profile.modelPath, profile.mmprojPath, null, profile.flags);
+    const est = estimateMemory(profile.modelPath, profile.mmprojPath, profile.drafterPath, profile.flags);
     return renderSection("Memory estimate", renderRows([
       ["Estimated total", pc.bold(`~${formatBytes(est.totalBytes)}`)],
       ["Model", formatBytes(est.modelBytes)],
+      ...(est.mmprojBytes ? [["Vision projector", formatBytes(est.mmprojBytes)]] : []),
+      ...(est.draftBytes ? [["Drafter (MTP)", formatBytes(est.draftBytes)]] : []),
       ["KV cache", est.kvBytes ? `~${formatBytes(est.kvBytes)} (${profile.flags.ctxSize.toLocaleString()} ctx, ${profile.flags.cacheTypeK}/${profile.flags.cacheTypeV})` : "unknown"],
       ...(est.note ? [["Note", pc.yellow(est.note)]] : []),
     ]));
@@ -269,8 +429,5 @@ async function runtimeSupportsGemma4Unified() {
   }
 }
 
-function samplingSummary(flags) {
-  return `temp ${flags.temperature}, top-p ${flags.topP}, top-k ${flags.topK}`;
-}
 
 

package/src/profiles.mjs

@@ -3,6 +3,7 @@ import { mkdir, readdir, rm, unlink, writeFile, readFile } from "node:fs/promise
 import { join } from "node:path";
 import { PROFILE_DIR, RUN_DIR, LOG_DIR } from "./config.mjs";
 import { backendFor, baseUrlForFlags, defaultFlagsForBackend, BACKENDS } from "./backends.mjs";
+import { detectCapabilities } from "./autodetect.mjs";
 import { computeFlags } from "./autodetect.mjs";
 import { readJson, writeJson } from "./json.mjs";
 
@@ -130,7 +131,6 @@ export function normalizeProfile(profile) {
 // ── Auto-create profile from a discovered model ────────────────────────────
 
 export async function createProfileFromModel(model, backendId, drafterPath) {
-  const { detectCapabilities } = await import("./autodetect.mjs");
   const caps = detectCapabilities(model.path, model.mmprojPath);
   // If a drafter is provided, this model supports MTP regardless of filename
   const hasMtp = caps.mtp || Boolean(drafterPath);

package/src/runtime.mjs

@@ -3,7 +3,7 @@ import { execFile } from "node:child_process";
 import { existsSync } from "node:fs";
 import { chmod, mkdir, mkdtemp, readFile, rm, symlink, unlink, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { basename, join } from "node:path";
+import { join } from "node:path";
 import { promisify } from "node:util";
 import { MANAGED_LLAMA_SERVER, RUNTIME_DIR } from "./config.mjs";
 import { compareVersions } from "./updates.mjs";
@@ -137,5 +137,5 @@ function verifyDigest(bytes, digest) {
   if (!digest?.startsWith("sha256:")) return;
   const expected = digest.slice("sha256:".length);
   const actual = createHash("sha256").update(bytes).digest("hex");
-  if (actual !== expected) throw new Error(`${basename("llama.cpp")}: checksum mismatch`);
+  if (actual !== expected) throw new Error("llama.cpp: checksum mismatch");
 }

package/src/ui.mjs

@@ -95,12 +95,12 @@ export function renderCard(title, body, options = {}) {
   }
 
   const topTitle = title ? `╭${pc.reset(titleStr)}` : "╭";
-  const topFill = "─".repeat(Math.max(0, width + 2 - visibleLen(titleStr)));
+  const topFill = "─".repeat(Math.max(0, width - visibleLen(titleStr)));
   const top = `${topTitle}${topFill}╮`;
 
   const middle = lines.map((line) => `│ ${padVisible(line, contentWidth)} │`);
 
-  const bottom = `╰${"─".repeat(width + 2)}╯`;
+  const bottom = `╰${"─".repeat(width)}╯`;
 
   return [top, ...middle, bottom].map((l) => borderColor(l)).join("\n");
 }
@@ -180,9 +180,8 @@ async function runPrompt(fn, config) {
 
 // ── Interactive prompt factory ──────────────────────────────────────────────
 
-export function startInteractive(title = "offgrid-ai") {
+export function startInteractive() {
   if (process.stdin.isTTY) console.clear();
-  console.log(pc.magenta(`◆ ${title}`));
 }
 
 export function createPrompt() {
@@ -195,10 +194,13 @@ export function createPrompt() {
       return value?.trim() || String(defaultValue ?? "");
     },
 
-    async number(label, defaultValue, min, max) {
+    async number(label, defaultValue, min, max, { float = false } = {}) {
       const value = await runPrompt(number, {
         message: label,
         default: defaultValue,
+        min,
+        max,
+        step: float ? 'any' : 1,
         validate(input) {
           if (!Number.isFinite(input) || input < min || input > max) {
             return `Enter a number from ${min} to ${max}.`;
@@ -235,12 +237,12 @@ export function createPrompt() {
 
 export async function modelSelect(label, groups, { defaultKey, pageSize = 20 } = {}) {
   const choices = [];
-  // Separator below the prompt message
-  choices.push(new Separator(pc.dim("  ────────────────────────────────────────────────────────────")));
+  // Blank line after the prompt message for visual separation
+  choices.push(new Separator(" "));
   for (let i = 0; i < groups.length; i++) {
     const group = groups[i];
     // Add blank line before each group (except the first)
-    if (i > 0) choices.push(new Separator(""));
+    if (i > 0) choices.push(new Separator(" "));
     if (group.separator) {
       choices.push(new Separator(group.separator));
     }