@tryhamster/gerbil 1.0.0-rc.9 → 1.0.1

package/dist/cli.mjs

@@ -1,17 +1,16 @@
 #!/usr/bin/env node
-import { t as __require } from "./chunk-CkXuGtQK.mjs";
-import { n as BUILTIN_MODELS, t as Gerbil } from "./gerbil-Dw4Qj77e.mjs";
-import { n as getChromeCachedModels, r as refreshCachedModelSizes } from "./chrome-backend-CORwaIyC.mjs";
-import "./utils-CZBZ8dgR.mjs";
-import "./one-liner-s-lD8rCC.mjs";
-import { D as listSkills, T as getSkillInfo, a as summarize, d as explain, k as useSkill, m as commit, s as review, v as loadProjectSkills } from "./skills-CD3Orlex.mjs";
-import { r as startMCPServer } from "./mcp-BvbriaBy.mjs";
-import { a as getToolDefinitions, c as setToolContext, i as getTool, n as executeToolCall, o as loadProjectTools, r as formatToolsForPrompt, s as parseToolCall } from "./tools-Bi1P7Xoy.mjs";
-import { exec, spawn, spawnSync } from "node:child_process";
+import { t as __require } from "./chunk-B9cbKln6.mjs";
+import { n as BUILTIN_MODELS, r as DEFAULT_MODEL, t as Gerbil } from "./gerbil-DNniplr4.mjs";
+import "./utils-DKO55ZmZ.mjs";
+import "./one-liner-JhdIPxzF.mjs";
+import { n as isArchitectureSupported } from "./architectures-C1I5V3Dt.mjs";
+import { A as useSkill, E as getSkillInfo, O as listSkills, a as summarize, f as explain, h as commit, s as review, y as loadProjectSkills } from "./skills-CU694Dc8.mjs";
+import { r as startMCPServer } from "./mcp-D2vvH1Xc.mjs";
+import { a as getToolDefinitions, c as setToolContext, i as getTool, n as executeToolCall, o as loadProjectTools, r as formatToolsForPrompt, s as parseToolCall } from "./tools-DQ1mPUw5.mjs";
 import fs, { existsSync, readFileSync, unlinkSync } from "node:fs";
-import http from "node:http";
 import os, { tmpdir } from "node:os";
 import path, { join } from "node:path";
+import { exec, spawn, spawnSync } from "node:child_process";
 import React, { useCallback, useEffect, useRef, useState } from "react";
 import chalk from "chalk";
 import { Command } from "commander";
@@ -22,9 +21,10 @@ import Spinner from "ink-spinner";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import SelectInput from "ink-select-input";
 import TextInput from "ink-text-input";
+import http from "node:http";
 
 //#region package.json
-var version = "1.0.0-rc.9";
+var version = "1.0.1";
 
 //#endregion
 //#region src/cli/repl/auto-update.ts
@@ -123,120 +123,82 @@ function getGerbilModelsDir() {
 	return path.join(process.cwd(), ".gerbil", "models");
 }
 /**
-* Get transformers.js cache directory (downloaded HF models)
+* Get the native WebGPU engine cache directory (downloaded safetensors models).
+* Layout: ~/.cache/gerbil/<repo>/<revision>/ — see src/gpu/model-loader.ts.
 */
-function getTransformersCacheDir() {
-	const nodeModulesCache = path.join(process.cwd(), "node_modules", "@huggingface", "transformers", ".cache");
-	if (fs.existsSync(nodeModulesCache)) return nodeModulesCache;
-	return process.env.HF_HOME || process.env.TRANSFORMERS_CACHE || path.join(os.homedir(), ".cache", "huggingface", "hub");
+function getNativeCacheDir() {
+	return path.join(os.homedir(), ".cache", "gerbil");
 }
 /**
-* Check if a model is cached locally (checks gerbil, transformers, and Chrome cache)
+* Check if a model is cached locally for the native engine.
+*
+* The native loader stores each repo under ~/.cache/gerbil/<repo>/<revision>/
+* (slashes in the repo replaced by underscores), plus the project-local
+* .gerbil/models dir. A model counts as cached when a safetensors weight file
+* is present somewhere under its directory.
 */
 function isModelCached(hfId) {
 	const [org, model] = hfId.split("/");
 	if (!(org && model)) return false;
-	try {
-		if (getChromeCachedModels().some((m) => m.modelId === hfId)) return true;
-	} catch {}
-	const cacheDirs = [getGerbilModelsDir(), getTransformersCacheDir()];
-	for (const cacheDir of cacheDirs) {
-		const possiblePaths = [
-			path.join(cacheDir, org, model),
-			path.join(cacheDir, hfId.replace("/", "--")),
-			path.join(cacheDir, `models--${org}--${model}`)
-		];
-		for (const p of possiblePaths) try {
-			if (fs.existsSync(p)) {
-				if (fs.statSync(p).isDirectory()) {
-					if (fs.readdirSync(p, { recursive: true }).some((f) => {
-						const fname = String(f).toLowerCase();
-						return fname.endsWith(".onnx") || fname.endsWith("model.safetensors") || fname.includes("decoder_model") || fname.includes("encoder_model");
-					})) return true;
-				}
-			}
-		} catch {}
-	}
-	return false;
+	const hasSafetensors = (root) => {
+		try {
+			if (!fs.existsSync(root)) return false;
+			if (!fs.statSync(root).isDirectory()) return false;
+			return fs.readdirSync(root, { recursive: true }).some((f) => String(f).toLowerCase().endsWith(".safetensors"));
+		} catch {
+			return false;
+		}
+	};
+	if (hasSafetensors(path.join(getNativeCacheDir(), hfId.replace(/\//g, "_")))) return true;
+	const gerbilDir = getGerbilModelsDir();
+	return [
+		path.join(gerbilDir, org, model),
+		path.join(gerbilDir, hfId.replace(/\//g, "_")),
+		path.join(gerbilDir, hfId.replace("/", "--"))
+	].some(hasSafetensors);
 }
 /**
 * Scan a single cache directory for models
 */
 function scanCacheDir(cacheDir, models) {
 	let totalBytes = 0;
+	const measure = (root) => {
+		let total = 0;
+		let modelBytes = 0;
+		try {
+			const files = fs.readdirSync(root, { recursive: true });
+			for (const file of files) try {
+				const fileStat = fs.statSync(path.join(root, String(file)));
+				if (fileStat.isFile()) {
+					total += fileStat.size;
+					if (String(file).toLowerCase().endsWith(".safetensors")) modelBytes += fileStat.size;
+				}
+			} catch {}
+		} catch {}
+		return {
+			total,
+			modelBytes
+		};
+	};
 	try {
 		if (!fs.existsSync(cacheDir)) return 0;
-		const entries = fs.readdirSync(cacheDir);
-		for (const entry of entries) {
+		for (const entry of fs.readdirSync(cacheDir)) {
 			const entryPath = path.join(cacheDir, entry);
-			const entryStat = fs.statSync(entryPath);
-			if (!entryStat.isDirectory()) continue;
-			let modelName = entry;
-			if (entry.startsWith("models--")) modelName = entry.replace("models--", "").replace("--", "/");
-			const subEntries = fs.readdirSync(entryPath);
-			for (const subEntry of subEntries) {
-				const subPath = path.join(entryPath, subEntry);
-				try {
-					const subStat = fs.statSync(subPath);
-					if (subStat.isDirectory()) {
-						const fullModelName = `${entry}/${subEntry}`;
-						let totalSize = 0;
-						let modelFileSize = 0;
-						try {
-							const files = fs.readdirSync(subPath, { recursive: true });
-							for (const file of files) try {
-								const filePath = path.join(subPath, String(file));
-								const fileStat = fs.statSync(filePath);
-								if (fileStat.isFile()) {
-									totalSize += fileStat.size;
-									const fname = String(file).toLowerCase();
-									if (fname.endsWith(".onnx") || fname.endsWith(".safetensors")) modelFileSize += fileStat.size;
-								}
-							} catch {}
-						} catch {
-							totalSize = subStat.size;
-						}
-						if (totalSize > 0) {
-							totalBytes += totalSize;
-							const lastUsed = formatTimeAgo(subStat.mtime);
-							models.push({
-								name: fullModelName,
-								modelSize: formatBytes(modelFileSize || totalSize),
-								totalSize: formatBytes(totalSize),
-								lastUsed,
-								location: cacheDir
-							});
-						}
-					}
-				} catch {}
-			}
-			if (subEntries.some((f) => f.endsWith(".onnx") || f.endsWith(".json"))) {
-				let totalSize = 0;
-				let modelFileSize = 0;
-				try {
-					const files = fs.readdirSync(entryPath, { recursive: true });
-					for (const file of files) try {
-						const filePath = path.join(entryPath, String(file));
-						const fileStat = fs.statSync(filePath);
-						if (fileStat.isFile()) {
-							totalSize += fileStat.size;
-							const fname = String(file).toLowerCase();
-							if (fname.endsWith(".onnx") || fname.endsWith(".safetensors")) modelFileSize += fileStat.size;
-						}
-					} catch {}
-				} catch {
-					totalSize = entryStat.size;
+			try {
+				const entryStat = fs.statSync(entryPath);
+				if (!entryStat.isDirectory()) continue;
+				const { total, modelBytes } = measure(entryPath);
+				if (total > 0) {
+					totalBytes += total;
+					models.push({
+						name: entry.replace(/_/g, "/"),
+						modelSize: formatBytes(modelBytes || total),
+						totalSize: formatBytes(total),
+						lastUsed: formatTimeAgo(entryStat.mtime),
+						location: cacheDir
+					});
 				}
-				totalBytes += totalSize;
-				const lastUsed = formatTimeAgo(entryStat.mtime);
-				models.push({
-					name: modelName,
-					modelSize: formatBytes(modelFileSize || totalSize),
-					totalSize: formatBytes(totalSize),
-					lastUsed,
-					location: cacheDir
-				});
-			}
+			} catch {}
 		}
 	} catch {}
 	return totalBytes;
@@ -246,32 +208,14 @@ function scanCacheDir(cacheDir, models) {
 */
 function getCacheInfo() {
 	const gerbilDir = getGerbilModelsDir();
-	const transformersDir = getTransformersCacheDir();
+	const nativeDir = getNativeCacheDir();
 	const models = [];
 	let totalBytes = 0;
 	totalBytes += scanCacheDir(gerbilDir, models);
-	totalBytes += scanCacheDir(transformersDir, models);
-	let hasMissingSizes = false;
-	try {
-		const chromeCached = getChromeCachedModels();
-		for (const entry of chromeCached) if (!models.some((m) => m.name === entry.modelId || m.name.replace("--", "/") === entry.modelId || entry.modelId.replace("/", "--") === m.name)) {
-			const lastUsed = entry.lastUsed ? formatTimeAgo(new Date(entry.lastUsed)) : "unknown";
-			if (!(entry.sizeBytes && entry.contextLength)) hasMissingSizes = true;
-			models.push({
-				name: entry.modelId,
-				modelSize: entry.sizeBytes ? formatBytes(entry.sizeBytes) : "~",
-				totalSize: entry.sizeBytes ? formatBytes(entry.sizeBytes) : "~",
-				lastUsed,
-				location: "Chrome IndexedDB",
-				contextLength: entry.contextLength
-			});
-			if (entry.sizeBytes) totalBytes += entry.sizeBytes;
-		}
-		if (hasMissingSizes) refreshCachedModelSizes().catch(() => {});
-	} catch {}
+	totalBytes += scanCacheDir(nativeDir, models);
 	const activeLocations = [...new Set(models.map((m) => m.location))];
 	return {
-		locations: activeLocations.length > 0 ? activeLocations : [gerbilDir, transformersDir],
+		locations: activeLocations.length > 0 ? activeLocations : [gerbilDir, nativeDir],
 		totalSize: formatBytes(totalBytes),
 		models: models.sort((a, b) => a.name.localeCompare(b.name))
 	};
@@ -304,50 +248,35 @@ function cleanResponse(text) {
 	return text.replace(/<think>[\s\S]*?<\/think>/g, "").replace(/<\/?think>/g, "").trim();
 }
 /**
-* Preset models with known performance
+* Preset models, native WebGPU engine only.
+*
+* The native engine loads standard HuggingFace safetensors repos and quantizes
+* to INT4 on the fly (dtype "q4"); there is no ONNX involved. Every entry here
+* is an architecture the engine supports (Qwen2/Qwen3/Qwen3.5, LFM2 — see
+* src/gpu/architectures/index.ts). `hfId` is the safetensors repo the loader
+* pulls and the key used for native cache detection.
 */
 const PRESET_MODELS = [
 	{
-		id: "qwen3-0.6b",
-		name: "Qwen3 0.6B",
-		size: "~400MB",
+		id: "qwen3.5-0.8b",
+		name: "Qwen3.5 0.8B",
+		size: "~500MB (q4)",
 		speed: "fastest",
-		hfId: "onnx-community/Qwen3-0.6B-ONNX"
+		hfId: "Qwen/Qwen3.5-0.8B"
 	},
 	{
-		id: "qwen2.5-0.5b",
-		name: "Qwen2.5 0.5B",
-		size: "~350MB",
+		id: "qwen3.5-2b",
+		name: "Qwen3.5 2B",
+		size: "~1.3GB (q4)",
 		speed: "fast",
-		hfId: "onnx-community/Qwen2.5-0.5B-Instruct"
+		hfId: "Qwen/Qwen3.5-2B"
 	},
 	{
-		id: "qwen2.5-coder-0.5b",
-		name: "Qwen2.5 Coder",
-		size: "~400MB",
+		id: "lfm2.5-1.2b-thinking",
+		name: "LFM2.5 1.2B Thinking",
+		size: "~760MB (q4)",
 		speed: "fast",
-		hfId: "onnx-community/Qwen2.5-Coder-0.5B-Instruct"
-	},
-	{
-		id: "smollm2-360m",
-		name: "SmolLM2 360M",
-		size: "~250MB",
-		speed: "fastest",
-		hfId: "HuggingFaceTB/SmolLM2-360M-Instruct"
-	},
-	{
-		id: "smollm2-135m",
-		name: "SmolLM2 135M",
-		size: "~100MB",
-		speed: "fastest",
-		hfId: "HuggingFaceTB/SmolLM2-135M-Instruct"
-	},
-	{
-		id: "phi-3-mini",
-		name: "Phi-3 Mini",
-		size: "~2.1GB",
-		speed: "medium",
-		hfId: "microsoft/Phi-3-mini-4k-instruct-onnx"
+		hfId: "LiquidAI/LFM2.5-1.2B-Thinking"
 	}
 ];
 /**
@@ -371,19 +300,12 @@ async function fetchModelMetadata(modelId) {
 		}
 	} catch {}
 	try {
-		const treeRes = await fetch(`https://huggingface.co/api/models/${modelId}/tree/main/onnx`);
+		const treeRes = await fetch(`https://huggingface.co/api/models/${modelId}/tree/main?recursive=true`);
 		if (treeRes.ok) {
 			const files = await treeRes.json();
 			const getSize = (f) => f.lfs?.size || f.size || 0;
-			const q4f16 = files.find((f) => f.path.includes("q4f16") && f.path.endsWith(".onnx"));
-			const q4 = files.find((f) => f.path.includes("q4") && !f.path.includes("f16") && f.path.endsWith(".onnx"));
-			const fp16 = files.find((f) => f.path.includes("fp16") && f.path.endsWith(".onnx"));
-			const anyOnnx = files.find((f) => f.path.endsWith(".onnx"));
-			const bestFile = q4f16 || q4 || fp16 || anyOnnx;
-			if (bestFile) {
-				const baseName = bestFile.path.replace(".onnx", "");
-				result.sizeBytes = files.filter((f) => f.path === bestFile.path || f.path.startsWith(`${baseName}.onnx_data`)).reduce((sum, f) => sum + getSize(f), 0);
-			}
+			const safetensors = files.filter((f) => f.path.toLowerCase().endsWith(".safetensors"));
+			if (safetensors.length > 0) result.sizeBytes = safetensors.reduce((sum, f) => sum + getSize(f), 0);
 		}
 	} catch {}
 	return result;
@@ -421,12 +343,12 @@ function saveBenchmark(result) {
 */
 /**
 * Normalize model ID for matching (extract core name)
-* e.g., "HuggingFaceTB/SmolLM2-135M-Instruct" -> "smollm2-135m"
-*       "onnx-community/Qwen3-0.6B-ONNX" -> "qwen3-0.6b"
-*       "qwen3-0.6b" -> "qwen3-0.6b"
+* e.g., "Qwen/Qwen3.5-0.8B" -> "qwen3.5-0.8b"
+*       "mlx-community/Qwen3.5-0.8B-4bit" -> "qwen3.5-0.8b"
+*       "qwen3.5-0.8b" -> "qwen3.5-0.8b"
 */
 function normalizeModelId(id) {
-	return (id.split("/").pop() || id).toLowerCase().replace(/-instruct$/i, "").replace(/-onnx$/i, "").replace(/-chat$/i, "").replace(/-it$/i, "");
+	return (id.split("/").pop() || id).toLowerCase().replace(/-instruct$/i, "").replace(/-onnx$/i, "").replace(/-4bit$/i, "").replace(/-chat$/i, "").replace(/-it$/i, "");
 }
 /**
 * Process an image path (URL or local file) and return info for attaching
@@ -508,7 +430,7 @@ function getModelBenchmarkStats(modelId) {
 
 //#endregion
 //#region src/cli/repl/views/BenchmarkView.tsx
-function BenchmarkView({ gerbil, model, disabled = false, onResult, onSwitchModel, onSwitchDevice, onStatusChange, benchmarkResults, setBenchmarkResults, benchmarkModels, setBenchmarkModels }) {
+function BenchmarkView({ gerbil, model, disabled = false, onResult, onSwitchModel, onStatusChange, benchmarkResults, setBenchmarkResults, benchmarkModels, setBenchmarkModels }) {
 	const [status, setStatus] = useState("idle");
 	const [currentRun, setCurrentRun] = useState(benchmarkResults.length);
 	const [showHistory, setShowHistory] = useState(false);
@@ -564,7 +486,6 @@ function BenchmarkView({ gerbil, model, disabled = false, onResult, onSwitchMode
 			setBenchmarkModels([model]);
 		}
 		if ((input === "m" || input === "M") && !blocked) onSwitchModel?.();
-		if ((input === "d" || input === "D") && !blocked) onSwitchDevice?.(currentDevice === "webgpu" ? "cpu" : "webgpu");
 		if ((input === "h" || input === "H") && !blocked) {
 			if (!showHistory) setHistoryData(getStoredBenchmarks());
 			setShowHistory(!showHistory);
@@ -593,25 +514,30 @@ function BenchmarkView({ gerbil, model, disabled = false, onResult, onSwitchMode
 			"List 3 benefits of TypeScript."
 		];
 		const prompt = prompts[currentRun % prompts.length];
-		const startTime = Date.now();
-		let firstTokenTime = 0;
-		let gotFirstToken = false;
+		const startTime = performance.now();
+		let firstTokenAt = 0;
+		let lastTokenAt = 0;
+		let tokenCount = 0;
 		const result = await gerbil.generate(prompt, {
 			maxTokens: 100,
 			onToken: () => {
-				if (!gotFirstToken) {
-					firstTokenTime = Date.now() - startTime;
-					gotFirstToken = true;
-				}
+				const now = performance.now();
+				tokenCount++;
+				if (tokenCount === 1) firstTokenAt = now;
+				lastTokenAt = now;
 			}
 		});
+		const endTime = performance.now();
+		const hasTokenEvents = tokenCount > 0;
+		const firstTokenMs = hasTokenEvents ? Math.round(firstTokenAt - startTime) : Math.round(result.totalTime * .15);
+		const tokensPerSec = hasTokenEvents ? tokenCount > 1 && lastTokenAt > firstTokenAt ? Math.round(tokenCount / (lastTokenAt - firstTokenAt) * 1e3) : Math.round(tokenCount / (endTime - startTime) * 1e3) : Math.round(result.tokensGenerated / result.totalTime * 1e3);
 		const newResult = {
 			model,
 			device: gerbil.getDeviceMode(),
-			tokensPerSec: Math.round(result.tokensPerSecond),
-			firstTokenMs: firstTokenTime || Math.round(result.totalTime * .1),
-			totalTokens: result.tokensGenerated,
-			totalMs: Math.round(result.totalTime)
+			tokensPerSec,
+			firstTokenMs,
+			totalTokens: hasTokenEvents ? tokenCount : result.tokensGenerated,
+			totalMs: Math.round(endTime - startTime)
 		};
 		saveBenchmark(newResult);
 		const updatedResults = [...benchmarkResults, newResult];
@@ -621,13 +547,11 @@ function BenchmarkView({ gerbil, model, disabled = false, onResult, onSwitchMode
 		onResult?.(newResult.tokensPerSec);
 	};
 	const currentResults = benchmarkResults.filter((r) => r.model === model && r.device === currentDevice);
-	const modelStats = [...new Set(benchmarkResults.map((r) => `${r.model}|${r.device}`))].map((key) => {
-		const [m, d] = key.split("|");
-		const results = benchmarkResults.filter((r) => r.model === m && r.device === d);
+	const modelStats = [...new Set(benchmarkResults.map((r) => r.model))].map((m) => {
+		const results = benchmarkResults.filter((r) => r.model === m);
 		if (results.length === 0) return null;
 		return {
 			model: m,
-			device: d,
 			runs: results.length,
 			avgTokPerSec: Math.round(results.reduce((a, r) => a + r.tokensPerSec, 0) / results.length),
 			avgFirstToken: Math.round(results.reduce((a, r) => a + r.firstTokenMs, 0) / results.length)
@@ -664,7 +588,7 @@ function BenchmarkView({ gerbil, model, disabled = false, onResult, onSwitchMode
 				/* @__PURE__ */ jsx(Text, { children: " on " }),
 				/* @__PURE__ */ jsx(Text, {
 					bold: true,
-					color: currentDevice === "webgpu" ? "green" : currentDevice === "cpu" ? "yellow" : "gray",
+					color: "green",
 					children: currentDevice.toUpperCase()
 				}),
 				modelStats.length > 1 && /* @__PURE__ */ jsxs(Text, {
@@ -672,7 +596,7 @@ function BenchmarkView({ gerbil, model, disabled = false, onResult, onSwitchMode
 					children: [
 						" (comparing ",
 						modelStats.length,
-						" configs)"
+						" models)"
 					]
 				})
 			] }),
@@ -735,22 +659,12 @@ function BenchmarkView({ gerbil, model, disabled = false, onResult, onSwitchMode
 						color: "green",
 						children: modelStats.length > 1 ? "Comparison:" : "Averages:"
 					}), modelStats.map((s) => {
-						const isCurrent = s.model === model && s.device === currentDevice;
-						const dColor = s.device === "webgpu" ? "green" : s.device === "cpu" ? "yellow" : "gray";
 						return /* @__PURE__ */ jsxs(Box, { children: [
 							/* @__PURE__ */ jsxs(Text, { children: [
-								isCurrent ? ">" : " ",
+								s.model === model ? ">" : " ",
 								" ",
 								s.model
 							] }),
-							/* @__PURE__ */ jsxs(Text, {
-								color: dColor,
-								children: [
-									" [",
-									s.device,
-									"]"
-								]
-							}),
 							/* @__PURE__ */ jsx(Text, { children: ": " }),
 							/* @__PURE__ */ jsxs(Text, {
 								bold: true,
@@ -774,7 +688,7 @@ function BenchmarkView({ gerbil, model, disabled = false, onResult, onSwitchMode
 								color: "green",
 								children: " *fastest*"
 							})
-						] }, `${s.model}-${s.device}`);
+						] }, s.model);
 					})]
 				}), bests && benchmarkResults.length >= 2 && /* @__PURE__ */ jsxs(Box, {
 					borderColor: "magenta",
@@ -803,11 +717,8 @@ function BenchmarkView({ gerbil, model, disabled = false, onResult, onSwitchMode
 							/* @__PURE__ */ jsxs(Text, {
 								dimColor: true,
 								children: [
-									" ",
-									"(",
+									" (",
 									bests.fastestRun.model,
-									" on ",
-									bests.fastestRun.device,
 									")"
 								]
 							})
@@ -827,11 +738,8 @@ function BenchmarkView({ gerbil, model, disabled = false, onResult, onSwitchMode
 							/* @__PURE__ */ jsxs(Text, {
 								dimColor: true,
 								children: [
-									" ",
-									"(",
+									" (",
 									bests.fastestFirstToken.model,
-									" on ",
-									bests.fastestFirstToken.device,
 									")"
 								]
 							})
@@ -851,12 +759,9 @@ function BenchmarkView({ gerbil, model, disabled = false, onResult, onSwitchMode
 								dimColor: true,
 								children: [
 									" ",
-									"on ",
-									bests.bestOverall.device,
-									" (",
+									"(",
 									bests.bestOverall.avgTokPerSec,
-									" tok/s,",
-									" ",
+									" tok/s, ",
 									bests.bestOverall.avgFirstToken,
 									"ms)"
 								]
@@ -917,9 +822,7 @@ function BenchmarkView({ gerbil, model, disabled = false, onResult, onSwitchMode
 									" ",
 									"- ",
 									b.model,
-									" [",
-									b.device,
-									"] ",
+									" ",
 									new Date(b.timestamp).toLocaleDateString()
 								]
 							})
@@ -960,14 +863,6 @@ function BenchmarkView({ gerbil, model, disabled = false, onResult, onSwitchMode
 							children: "Enter"
 						}),
 						" run | ",
-						/* @__PURE__ */ jsx(Text, {
-							color: "yellow",
-							children: "d"
-						}),
-						" switch",
-						" ",
-						currentDevice === "webgpu" ? "CPU" : "GPU",
-						" | ",
 						/* @__PURE__ */ jsx(Text, {
 							color: "yellow",
 							children: "m"
@@ -1667,9 +1562,7 @@ function ChatView({ gerbil, thinkingMode, agentMode, voiceMode, onToggleThinking
 	}, []);
 	const modes = Object.keys(CHAT_MODES);
 	const modelInfo = gerbil.getModelInfo();
-	const modelId = modelInfo?.repo;
-	const cachedModels = modelId ? getChromeCachedModels() : [];
-	const maxContext = (modelId ? cachedModels.find((m) => m.modelId === modelId) : null)?.contextLength || modelInfo?.contextLength || 32768;
+	const maxContext = modelInfo?.contextLength || 32768;
 	const currentTokens = estimateTokens(buildConversationContext(messages, mode));
 	const contextPercent = Math.round(currentTokens / maxContext * 100);
 	const ACTION_COUNT = supportsVision ? 5 : 4;
@@ -2035,11 +1928,9 @@ function ChatView({ gerbil, thinkingMode, agentMode, voiceMode, onToggleThinking
 				setInput("");
 				try {
 					await gerbil.clearCache();
-					const mem = await gerbil.getMemoryUsage();
-					const memInfo = mem ? ` (was ${mem.usedGB.toFixed(1)}GB)` : "";
 					setMessages((m) => [...m, {
 						role: "system",
-						content: `🧹 Cache cleared${memInfo}. Conversation context reset.`
+						content: "🧹 Cache cleared. Conversation context reset."
 					}]);
 				} catch (err) {
 					setMessages((m) => [...m, {
@@ -2052,14 +1943,11 @@ function ChatView({ gerbil, thinkingMode, agentMode, voiceMode, onToggleThinking
 			if (cmd === "memory" || cmd === "mem") {
 				setInput("");
 				try {
-					const mem = await gerbil.getMemoryUsage();
-					if (mem) setMessages((m) => [...m, {
-						role: "system",
-						content: `💾 Memory: ${mem.usedGB.toFixed(1)}GB / ${mem.totalGB.toFixed(1)}GB (${mem.usedPercent.toFixed(1)}%)`
-					}]);
-					else setMessages((m) => [...m, {
+					const sys = getMemoryInfo();
+					const rssMB = (process.memoryUsage().rss / 1024 / 1024).toFixed(0);
+					setMessages((m) => [...m, {
 						role: "system",
-						content: "Memory monitoring not available (CPU mode)"
+						content: `💾 Process RSS: ${rssMB} MB · System: ${sys.used} / ${sys.total} (${sys.percentUsed}%)`
 					}]);
 				} catch (err) {
 					setMessages((m) => [...m, {
@@ -3785,10 +3673,6 @@ const CAPABILITIES = [
 		id: "text",
 		name: "Text"
 	},
-	{
-		id: "vision",
-		name: "Vision"
-	},
 	{
 		id: "tts",
 		name: "Text to Speech"
@@ -3836,7 +3720,7 @@ const EXAMPLES = {
 			code: `import { Gerbil } from "@tryhamster/gerbil";
 
 const g = new Gerbil();
-await g.loadModel("qwen3-0.6b");
+await g.loadModel("qwen3.5-0.8b");
 
 // Generate text
 const result = await g.generate("Write a haiku", {
@@ -3863,13 +3747,13 @@ import { gerbil } from "@tryhamster/gerbil/ai";
 
 // Generate
 const { text } = await generateText({
-  model: gerbil("qwen3-0.6b"),
+  model: gerbil("qwen3.5-0.8b"),
   prompt: "Explain quantum computing",
 });
 
 // Stream
 const { textStream } = streamText({
-  model: gerbil("qwen3-0.6b"),
+  model: gerbil("qwen3.5-0.8b"),
   system: "You are a helpful assistant.",
   messages: [{ role: "user", content: "Hello!" }],
 });
@@ -3881,20 +3765,20 @@ for await (const chunk of textStream) {
 		browser: {
 			install: "npm install @tryhamster/gerbil",
 			description: "React hooks for browser-based inference with WebGPU.",
-			code: `import { useChat, useCompletion } from "@tryhamster/gerbil/browser";
+			code: `import { useChat, useCompletion } from "@tryhamster/gerbil/hooks";
 
-// useChat - Full chat with message history
+// useChat - Full chat with message history (history is sent each turn)
 function Chat() {
-  const { messages, input, setInput, handleSubmit, isLoading } = useChat({
-    model: "qwen3-0.6b",
+  const { messages, send, isGenerating, isLoading } = useChat({
+    model: "qwen3.5-0.8b",
     thinking: true,
   });
   if (isLoading) return <div>Loading...</div>;
   return (
-    <form onSubmit={handleSubmit}>
-      {messages.map(m => <div key={m.id}>{m.role}: {m.content}</div>)}
-      <input value={input} onChange={e => setInput(e.target.value)} />
-    </form>
+    <div>
+      {messages.map((m, i) => <div key={i}>{m.role}: {m.content}</div>)}
+      <button disabled={isGenerating} onClick={() => send("Hello!")}>Send</button>
+    </div>
   );
 }
 
@@ -3912,7 +3796,7 @@ function Generator() {
 import { gerbil } from "@tryhamster/gerbil/next";
 
 export const POST = gerbil.handler({ 
-  model: "qwen3-0.6b",
+  model: "qwen3.5-0.8b",
   system: "You are a helpful assistant.",
 });
 
@@ -3928,7 +3812,7 @@ import { gerbil } from "@tryhamster/gerbil/express";
 
 const app = express();
 app.use(express.json());
-app.use("/api/ai", gerbil({ model: "qwen3-0.6b" })());
+app.use("/api/ai", gerbil({ model: "qwen3.5-0.8b" })());
 
 // POST /api/ai/generate  { prompt, options }
 // POST /api/ai/stream    { prompt, options } (SSE)
@@ -3944,7 +3828,7 @@ import { PromptTemplate } from "langchain/prompts";
 import { LLMChain } from "langchain/chains";
 
 const llm = new GerbilLLM({ 
-  model: "qwen3-0.6b",
+  model: "qwen3.5-0.8b",
   temperature: 0.7,
 });
 
@@ -3953,135 +3837,6 @@ const chain = new LLMChain({ llm, prompt });
 const result = await chain.call({ text: "..." });`
 		}
 	},
-	vision: {
-		standalone: {
-			install: "npm install @tryhamster/gerbil",
-			description: "Vision models for image understanding and description.",
-			code: `import { Gerbil } from "@tryhamster/gerbil";
-
-const g = new Gerbil();
-await g.loadModel("ministral-3b"); // Vision-capable model
-
-// Describe an image
-const result = await g.generate("What's in this image?", {
-  images: [{ source: "https://example.com/photo.jpg" }]
-});
-console.log(result.text);
-
-// Compare images
-const diff = await g.generate("What's different?", {
-  images: [
-    { source: "before.jpg" },
-    { source: "after.jpg" }
-  ]
-});
-
-// Check if model supports vision
-console.log(g.supportsVision()); // true`
-		},
-		"ai-sdk": {
-			install: "npm install @tryhamster/gerbil ai",
-			description: "AI SDK with image content parts.",
-			code: `import { generateText } from "ai";
-import { gerbil } from "@tryhamster/gerbil/ai";
-
-const { text } = await generateText({
-  model: gerbil("ministral-3b"),
-  messages: [{
-    role: "user",
-    content: [
-      { type: "image", image: new URL("https://example.com/photo.jpg") },
-      { type: "text", text: "Describe this image in detail" },
-    ],
-  }],
-});
-
-// Also accepts:
-// - Base64 strings: { type: "image", image: "data:image/png;base64,..." }
-// - Uint8Array: { type: "image", image: bytes, mimeType: "image/png" }`
-		},
-		browser: {
-			install: "npm install @tryhamster/gerbil",
-			description: "React hooks with image attachment support.",
-			code: `import { useChat } from "@tryhamster/gerbil/browser";
-
-function VisionChat() {
-  const { messages, input, setInput, handleSubmit, attachImage, attachedImages } = useChat({
-    model: "ministral-3b"
-  });
-
-  const handleFile = (e) => {
-    const file = e.target.files?.[0];
-    if (file) {
-      const reader = new FileReader();
-      reader.onload = () => attachImage(reader.result);
-      reader.readAsDataURL(file);
-    }
-  };
-
-  return (
-    <div>
-      {messages.map(m => <div key={m.id}>{m.content}</div>)}
-      <input type="file" accept="image/*" onChange={handleFile} />
-      {attachedImages.length > 0 && <span>📎 {attachedImages.length} attached</span>}
-      <form onSubmit={handleSubmit}>
-        <input value={input} onChange={e => setInput(e.target.value)} />
-      </form>
-    </div>
-  );
-}`
-		},
-		nextjs: {
-			install: "npm install @tryhamster/gerbil",
-			description: "Next.js vision endpoint with image handling.",
-			code: `// app/api/vision/route.ts
-import { gerbil } from "@tryhamster/gerbil/next";
-
-export const POST = gerbil.handler({ model: "ministral-3b" });
-
-// Client fetch:
-// await fetch("/api/vision", {
-//   method: "POST",
-//   body: JSON.stringify({
-//     prompt: "What's in this image?",
-//     images: [{ source: dataUri }]
-//   })
-// });`
-		},
-		express: {
-			install: "npm install @tryhamster/gerbil express",
-			description: "Express vision endpoint with image input.",
-			code: `import express from "express";
-import { gerbil } from "@tryhamster/gerbil/express";
-
-const app = express();
-app.use(express.json({ limit: "10mb" })); // For large images
-app.use("/api/vision", gerbil({ model: "ministral-3b" })());
-
-// POST /api/vision/generate
-// Body: { prompt: "Describe this", images: [{ source: "..." }] }
-
-app.listen(3000);`
-		},
-		langchain: {
-			install: "npm install @tryhamster/gerbil langchain",
-			description: "LangChain LLM with vision support.",
-			code: `import { GerbilLLM } from "@tryhamster/gerbil/langchain";
-
-const llm = new GerbilLLM({ model: "ministral-3b" });
-
-// Check vision support
-const hasVision = await llm.supportsVision();
-
-// Generate with images
-const result = await llm.invokeWithImages(
-  "Describe what you see in this image",
-  [{ source: "https://example.com/photo.jpg" }]
-);
-
-console.log(result);`
-		}
-	},
 	tts: {
 		standalone: {
 			install: "npm install @tryhamster/gerbil",
@@ -4132,24 +3887,26 @@ const voices = gerbil.listVoices();
 		browser: {
 			install: "npm install @tryhamster/gerbil",
 			description: "React hook for browser TTS with playback.",
-			code: `import { useSpeech } from "@tryhamster/gerbil/browser";
+			code: `import { useTTS, KANI_VOICES, type SpeakOptions } from "@tryhamster/gerbil/hooks";
+import { useState } from "react";
 
 function SpeechDemo() {
-  const { speak, stop, isSpeaking, isLoading, listVoices, setVoice } = useSpeech();
+  const { speak, stop, isPlaying, isLoading } = useTTS();
+  const [voice, setVoice] = useState<SpeakOptions["voice"]>(KANI_VOICES[0].value);
 
   if (isLoading) return <div>Loading TTS model...</div>;
 
   return (
     <div>
-      <select onChange={e => setVoice(e.target.value)}>
-        {listVoices().map(v => (
-          <option key={v.id} value={v.id}>{v.name} ({v.language})</option>
+      <select value={voice} onChange={e => setVoice(e.target.value as SpeakOptions["voice"])}>
+        {KANI_VOICES.map(v => (
+          <option key={v.value} value={v.value}>{v.label}</option>
         ))}
       </select>
-      <button onClick={() => speak("Hello world!")}>
-        {isSpeaking ? "Speaking..." : "Speak"}
+      <button onClick={() => speak("Hello world!", { voice })}>
+        {isPlaying ? "Speaking..." : "Speak"}
       </button>
-      {isSpeaking && <button onClick={stop}>Stop</button>}
+      {isPlaying && <button onClick={stop}>Stop</button>}
     </div>
   );
 }`
@@ -4273,33 +4030,32 @@ const models = gerbil.listTranscriptionModels();`
 		browser: {
 			install: "npm install @tryhamster/gerbil",
 			description: "React hooks for recording and transcription.",
-			code: `import { useVoiceInput, useVoiceChat } from "@tryhamster/gerbil/browser";
+			code: `import { useSTT, useVoiceChat } from "@tryhamster/gerbil/hooks";
 
 // Record and transcribe
 function VoiceInput() {
-  const { startRecording, stopRecording, isRecording, transcript } = useVoiceInput({
-    model: "whisper-tiny.en",
-    onTranscript: (text) => console.log("User said:", text),
-  });
+  const { startRecording, stopRecording, isRecording, transcript } = useSTT();
 
   return (
-    <button onClick={isRecording ? stopRecording : startRecording}>
-      {isRecording ? "🔴 Stop" : "🎤 Record"}
-    </button>
+    <div>
+      <button onClick={isRecording ? stopRecording : startRecording}>
+        {isRecording ? "🔴 Stop" : "🎤 Record"}
+      </button>
+      {transcript && <p>{transcript}</p>}
+    </div>
   );
 }
 
 // Full voice conversation: STT → LLM → TTS
 function VoiceAssistant() {
-  const { startListening, stopListening, stage, messages } = useVoiceChat({
-    llmModel: "qwen3-0.6b",
-    sttModel: "whisper-tiny.en",
-    voice: "af_bella",
+  const { start, stop, isListening, messages } = useVoiceChat({
+    model: "qwen3.5-0.8b",
+    voice: "en_us",
   });
 
   return (
-    <button onMouseDown={startListening} onMouseUp={stopListening}>
-      {stage === "idle" ? "🎤 Hold to Speak" : stage}
+    <button onMouseDown={start} onMouseUp={stop}>
+      {isListening ? "Listening..." : "🎤 Hold to Speak"}
     </button>
   );
 }`
@@ -4428,25 +4184,21 @@ const result = await g.embed("Your text here");
 		browser: {
 			install: "npm install @tryhamster/gerbil",
 			description: "Browser-based embeddings with WebGPU.",
-			code: `import { createGerbilWorker } from "@tryhamster/gerbil/browser";
+			code: `import { useEmbedding } from "@tryhamster/gerbil/hooks";
 
-// Create worker for embeddings
-const worker = await createGerbilWorker({ modelId: "qwen3-0.6b" });
+function Embeddings() {
+  const { embed, similarity, isLoading } = useEmbedding();
 
-// Note: Browser embeddings use the main model
-// For dedicated embedding model, use Gerbil on server
+  if (isLoading) return <div>Loading embedding model...</div>;
 
-// Server-side approach (recommended):
-// 1. Create API endpoint with Gerbil
-// 2. Call from browser
+  const run = async () => {
+    const { vector } = await embed("Hello world"); // number[]
+    const score = await similarity("cat", "kitten"); // 0..1
+    console.log(vector.length, score);
+  };
 
-// app/api/embed/route.ts
-// const g = new Gerbil();
-// export async function POST(req) {
-//   const { text } = await req.json();
-//   const result = await g.embed(text);
-//   return Response.json(result);
-// }`
+  return <button onClick={run}>Embed</button>;
+}`
 		},
 		nextjs: {
 			install: "npm install @tryhamster/gerbil",
@@ -4665,106 +4417,33 @@ function FrameworksView() {
 //#region src/cli/repl/views/InfoView.tsx
 function getDeviceLabel(deviceMode) {
 	const platform = os.platform();
-	const arch = os.arch();
 	if (deviceMode === "webgpu") {
-		if (platform === "darwin" && arch === "arm64") return "WebGPU (Chrome → Metal)";
-		if (platform === "linux") return "WebGPU (Chrome → Vulkan)";
-		if (platform === "win32") return "WebGPU (Chrome → D3D12)";
-		return "WebGPU (Chrome)";
+		if (platform === "darwin") return "WebGPU (Dawn → Metal)";
+		if (platform === "linux") return "WebGPU (Dawn → Vulkan)";
+		if (platform === "win32") return "WebGPU (Dawn → D3D12)";
+		return "WebGPU (Dawn)";
 	}
-	if (platform === "darwin" && arch === "arm64") return `Apple Silicon (${deviceMode.toUpperCase()})`;
-	if (platform === "darwin" && arch === "x64") return `Intel Mac (${deviceMode.toUpperCase()})`;
 	return deviceMode.toUpperCase();
 }
 function InfoView({ gerbil, model, modelFamily, stats, onGoToCache }) {
 	const deviceMode = gerbil.getDeviceMode();
 	const dtype = gerbil.getDtype();
-	const chromeStatus = gerbil.getChromeStatus();
 	const deviceLabel = getDeviceLabel(deviceMode);
 	const cacheInfo = getCacheInfo();
 	const memInfo = getMemoryInfo();
-	const [webgpuInfo, setWebgpuInfo] = useState(null);
-	const [allPages, setAllPages] = useState([]);
-	const [totalPageCount, setTotalPageCount] = useState(0);
-	const [selectedIndex, setSelectedIndex] = useState(-1);
-	const [killing, setKilling] = useState(false);
-	const [killResult, setKillResult] = useState(null);
 	const [ttsInfo, setTtsInfo] = useState(gerbil.getTTSModelInfo());
 	const [sttInfo, setSttInfo] = useState(gerbil.getSTTModelInfo());
-	const fetchInfo = useCallback(async () => {
-		const [info, pages, totalPages] = await Promise.all([
-			Gerbil.getWebGPUProcesses(),
-			Gerbil.getAllChromePagesInfo(),
-			Gerbil.getTotalChromePageCount()
-		]);
-		setWebgpuInfo(info);
-		setAllPages(pages || []);
-		setTotalPageCount(totalPages);
-		setTtsInfo(gerbil.getTTSModelInfo());
-		setSttInfo(gerbil.getSTTModelInfo());
-		const pageCount = pages?.length ?? 0;
-		if (selectedIndex >= pageCount) setSelectedIndex(pageCount > 0 ? 0 : -1);
-	}, [selectedIndex, gerbil]);
 	useEffect(() => {
-		fetchInfo();
-		const interval = setInterval(fetchInfo, 2e3);
+		const refresh = () => {
+			setTtsInfo(gerbil.getTTSModelInfo());
+			setSttInfo(gerbil.getSTTModelInfo());
+		};
+		refresh();
+		const interval = setInterval(refresh, 2e3);
 		return () => clearInterval(interval);
-	}, [fetchInfo]);
-	useInput(async (input, key) => {
-		if (input === "c" || input === "C") {
-			onGoToCache?.();
-			return;
-		}
-		if (input === "r" || input === "R") {
-			await fetchInfo();
-			return;
-		}
-		const pageCount = allPages.length;
-		if (pageCount > 0) {
-			if (key.downArrow || input === "j") {
-				setSelectedIndex((prev) => Math.min(prev + 1, pageCount - 1));
-				return;
-			}
-			if (key.upArrow || input === "k") {
-				setSelectedIndex((prev) => Math.max(prev - 1, 0));
-				return;
-			}
-			const num = Number.parseInt(input, 10);
-			if (num >= 1 && num <= 9 && num <= pageCount) {
-				setSelectedIndex(num - 1);
-				return;
-			}
-		}
-		if (input === "x" && !killing && selectedIndex >= 0 && allPages[selectedIndex]) {
-			setKilling(true);
-			setKillResult(null);
-			try {
-				const page = allPages[selectedIndex];
-				if (await Gerbil.killChromePage(selectedIndex)) setKillResult(`Killed: ${page.modelId?.split("/").pop() || "page"}${page.isOurs ? "" : " (other session)"}`);
-				else setKillResult("Failed to kill page");
-				await fetchInfo();
-			} catch (err) {
-				setKillResult(`Error: ${err.message}`);
-			}
-			setKilling(false);
-			setTimeout(() => setKillResult(null), 3e3);
-			return;
-		}
-		if (input === "K" && !killing && webgpuInfo?.browser.running) {
-			setKilling(true);
-			setKillResult(null);
-			try {
-				const result = await Gerbil.killAllWebGPU();
-				if (result) setKillResult(`Killed ${result.pagesKilled} page(s)${result.browserKilled ? ", browser closed" : ""}`);
-				else setKillResult("No WebGPU processes to kill");
-				await fetchInfo();
-				setSelectedIndex(-1);
-			} catch (err) {
-				setKillResult(`Error: ${err.message}`);
-			}
-			setKilling(false);
-			setTimeout(() => setKillResult(null), 3e3);
-		}
+	}, [gerbil]);
+	useInput((input) => {
+		if (input === "c" || input === "C") onGoToCache?.();
 	});
 	return /* @__PURE__ */ jsxs(Box, {
 		flexDirection: "column",
@@ -4803,10 +4482,18 @@ function InfoView({ gerbil, model, modelFamily, stats, onGoToCache }) {
 						color: deviceMode === "webgpu" ? "green" : "yellow",
 						children: deviceLabel
 					})] }),
-					/* @__PURE__ */ jsxs(Text, { children: ["Dtype: ", /* @__PURE__ */ jsx(Text, {
-						color: dtype === "q4f16" ? "green" : "gray",
-						children: dtype
-					})] })
+					/* @__PURE__ */ jsxs(Text, { children: [
+						"Weights: ",
+						/* @__PURE__ */ jsx(Text, {
+							color: "green",
+							children: dtype
+						}),
+						" ",
+						/* @__PURE__ */ jsx(Text, {
+							dimColor: true,
+							children: "(INT4, quantized on load)"
+						})
+					] })
 				]
 			}),
 			/* @__PURE__ */ jsxs(Box, {
@@ -4900,269 +4587,88 @@ function InfoView({ gerbil, model, modelFamily, stats, onGoToCache }) {
 			/* @__PURE__ */ jsxs(Box, {
 				flexDirection: "row",
 				marginBottom: 1,
-				children: [
-					/* @__PURE__ */ jsxs(Box, {
-						borderColor: "gray",
-						borderStyle: "single",
-						flexDirection: "column",
-						marginRight: 1,
-						minWidth: 30,
-						paddingX: 1,
-						children: [
-							/* @__PURE__ */ jsx(Text, {
-								bold: true,
-								color: "cyan",
-								children: "Memory"
-							}),
-							/* @__PURE__ */ jsxs(Text, { children: ["Total: ", /* @__PURE__ */ jsx(Text, {
-								color: "gray",
-								children: memInfo.total
-							})] }),
-							/* @__PURE__ */ jsxs(Text, { children: [
-								"Used:",
-								" ",
-								/* @__PURE__ */ jsxs(Text, {
-									color: memInfo.percentUsed > 80 ? "red" : "yellow",
-									children: [
-										memInfo.used,
-										" (",
-										memInfo.percentUsed,
-										"%)"
-									]
-								})
-							] }),
-							/* @__PURE__ */ jsxs(Text, { children: ["Free: ", /* @__PURE__ */ jsx(Text, {
+				children: [/* @__PURE__ */ jsxs(Box, {
+					borderColor: "gray",
+					borderStyle: "single",
+					flexDirection: "column",
+					marginRight: 1,
+					minWidth: 30,
+					paddingX: 1,
+					children: [
+						/* @__PURE__ */ jsx(Text, {
+							bold: true,
+							color: "cyan",
+							children: "Memory"
+						}),
+						/* @__PURE__ */ jsxs(Text, { children: ["Total: ", /* @__PURE__ */ jsx(Text, {
+							color: "gray",
+							children: memInfo.total
+						})] }),
+						/* @__PURE__ */ jsxs(Text, { children: [
+							"Used:",
+							" ",
+							/* @__PURE__ */ jsxs(Text, {
+								color: memInfo.percentUsed > 80 ? "red" : "yellow",
+								children: [
+									memInfo.used,
+									" (",
+									memInfo.percentUsed,
+									"%)"
+								]
+							})
+						] }),
+						/* @__PURE__ */ jsxs(Text, { children: ["Free: ", /* @__PURE__ */ jsx(Text, {
+							color: "green",
+							children: memInfo.free
+						})] })
+					]
+				}), /* @__PURE__ */ jsxs(Box, {
+					borderColor: "gray",
+					borderStyle: "single",
+					flexDirection: "column",
+					marginRight: 1,
+					minWidth: 30,
+					paddingX: 1,
+					children: [
+						/* @__PURE__ */ jsx(Text, {
+							bold: true,
+							color: "cyan",
+							children: "Session Stats"
+						}),
+						/* @__PURE__ */ jsxs(Text, { children: ["Prompts: ", /* @__PURE__ */ jsx(Text, {
+							color: "gray",
+							children: stats.prompts
+						})] }),
+						/* @__PURE__ */ jsxs(Text, { children: ["Tokens In: ", /* @__PURE__ */ jsx(Text, {
+							color: "gray",
+							children: stats.tokensIn
+						})] }),
+						/* @__PURE__ */ jsxs(Text, { children: ["Tokens Out: ", /* @__PURE__ */ jsx(Text, {
+							color: "gray",
+							children: stats.tokensOut
+						})] }),
+						/* @__PURE__ */ jsxs(Text, { children: ["Total Time: ", /* @__PURE__ */ jsxs(Text, {
+							color: "gray",
+							children: [Math.round(stats.totalTimeMs / 1e3), "s"]
+						})] }),
+						stats.lastTokPerSec > 0 && /* @__PURE__ */ jsxs(Text, { children: ["Last tok/s: ", /* @__PURE__ */ jsx(Text, {
+							color: "yellow",
+							children: stats.lastTokPerSec.toFixed(1)
+						})] }),
+						stats.avgTokPerSec > 0 && /* @__PURE__ */ jsxs(Text, { children: ["Avg tok/s: ", /* @__PURE__ */ jsx(Text, {
+							color: "cyan",
+							children: stats.avgTokPerSec.toFixed(1)
+						})] }),
+						stats.benchResults.length > 0 && /* @__PURE__ */ jsxs(Text, { children: [
+							"Best Bench:",
+							" ",
+							/* @__PURE__ */ jsxs(Text, {
 								color: "green",
-								children: memInfo.free
-							})] })
-						]
-					}),
-					/* @__PURE__ */ jsxs(Box, {
-						borderColor: "gray",
-						borderStyle: "single",
-						flexDirection: "column",
-						marginRight: 1,
-						minWidth: 30,
-						paddingX: 1,
-						children: [
-							/* @__PURE__ */ jsx(Text, {
-								bold: true,
-								color: "cyan",
-								children: "Session Stats"
-							}),
-							/* @__PURE__ */ jsxs(Text, { children: ["Prompts: ", /* @__PURE__ */ jsx(Text, {
-								color: "gray",
-								children: stats.prompts
-							})] }),
-							/* @__PURE__ */ jsxs(Text, { children: ["Tokens In: ", /* @__PURE__ */ jsx(Text, {
-								color: "gray",
-								children: stats.tokensIn
-							})] }),
-							/* @__PURE__ */ jsxs(Text, { children: ["Tokens Out: ", /* @__PURE__ */ jsx(Text, {
-								color: "gray",
-								children: stats.tokensOut
-							})] }),
-							/* @__PURE__ */ jsxs(Text, { children: ["Total Time: ", /* @__PURE__ */ jsxs(Text, {
-								color: "gray",
-								children: [Math.round(stats.totalTimeMs / 1e3), "s"]
-							})] }),
-							stats.lastTokPerSec > 0 && /* @__PURE__ */ jsxs(Text, { children: ["Last tok/s: ", /* @__PURE__ */ jsx(Text, {
-								color: "yellow",
-								children: stats.lastTokPerSec.toFixed(1)
-							})] }),
-							stats.avgTokPerSec > 0 && /* @__PURE__ */ jsxs(Text, { children: ["Avg tok/s: ", /* @__PURE__ */ jsx(Text, {
-								color: "cyan",
-								children: stats.avgTokPerSec.toFixed(1)
-							})] }),
-							stats.benchResults.length > 0 && /* @__PURE__ */ jsxs(Text, { children: [
-								"Best Bench:",
-								" ",
-								/* @__PURE__ */ jsxs(Text, {
-									color: "green",
-									children: [Math.max(...stats.benchResults.map((b) => b.tokPerSec)), " tok/s"]
-								})
-							] })
-						]
-					}),
-					chromeStatus && /* @__PURE__ */ jsxs(Box, {
-						borderColor: "green",
-						borderStyle: "single",
-						flexDirection: "column",
-						minWidth: 38,
-						paddingX: 1,
-						children: [
-							/* @__PURE__ */ jsx(Text, {
-								bold: true,
-								color: "green",
-								children: "WebGPU Backend"
-							}),
-							/* @__PURE__ */ jsxs(Text, { children: ["Status: ", /* @__PURE__ */ jsx(Text, {
-								color: "green",
-								children: "● Running"
-							})] }),
-							/* @__PURE__ */ jsxs(Text, { children: [
-								"PID:",
-								" ",
-								/* @__PURE__ */ jsx(Text, {
-									color: chromeStatus.pid ? "gray" : "yellow",
-									children: chromeStatus.pid ?? "connected (no PID)"
-								})
-							] }),
-							/* @__PURE__ */ jsxs(Text, { children: ["Port: ", /* @__PURE__ */ jsx(Text, {
-								color: "gray",
-								children: chromeStatus.port
-							})] }),
-							/* @__PURE__ */ jsxs(Text, { children: [
-								"Model:",
-								" ",
-								/* @__PURE__ */ jsx(Text, {
-									color: "gray",
-									children: chromeStatus.modelId.length > 28 ? `...${chromeStatus.modelId.slice(-25)}` : chromeStatus.modelId
-								})
-							] })
-						]
-					})
-				]
-			}),
-			webgpuInfo && /* @__PURE__ */ jsxs(Box, {
-				borderColor: webgpuInfo.browser.running ? "green" : "gray",
-				borderStyle: "single",
-				flexDirection: "column",
-				marginBottom: 1,
-				paddingX: 1,
-				children: [
-					/* @__PURE__ */ jsxs(Text, {
-						bold: true,
-						color: webgpuInfo.browser.running ? "green" : "gray",
-						children: ["WebGPU Processes ", /* @__PURE__ */ jsx(Text, {
-							dimColor: true,
-							children: "(all sessions)"
-						})]
-					}),
-					/* @__PURE__ */ jsxs(Text, { children: [
-						"Chrome:",
-						" ",
-						/* @__PURE__ */ jsx(Text, {
-							color: webgpuInfo.browser.running ? "green" : "gray",
-							children: webgpuInfo.browser.running ? "● Running" : "○ Not running"
-						})
-					] }),
-					webgpuInfo.browser.running && /* @__PURE__ */ jsxs(Fragment, { children: [
-						/* @__PURE__ */ jsxs(Text, { children: [
-							" ",
-							"PID: ",
-							/* @__PURE__ */ jsx(Text, {
-								color: "gray",
-								children: webgpuInfo.browser.pid ?? "unknown"
-							})
-						] }),
-						/* @__PURE__ */ jsxs(Text, { children: [
-							" ",
-							"Port: ",
-							/* @__PURE__ */ jsx(Text, {
-								color: "gray",
-								children: webgpuInfo.browser.port
-							})
-						] }),
-						/* @__PURE__ */ jsxs(Text, { children: [
-							" ",
-							"Total Pages:",
-							" ",
-							/* @__PURE__ */ jsx(Text, {
-								color: totalPageCount > 0 ? "yellow" : "gray",
-								children: totalPageCount
-							}),
-							" ",
-							/* @__PURE__ */ jsxs(Text, {
-								dimColor: true,
-								children: [
-									"(",
-									webgpuInfo.browser.activePagesCount,
-									" ours)"
-								]
+								children: [Math.max(...stats.benchResults.map((b) => b.tokPerSec)), " tok/s"]
 							})
 						] })
-					] }),
-					allPages.length > 0 && /* @__PURE__ */ jsxs(Box, {
-						flexDirection: "column",
-						marginTop: 1,
-						children: [/* @__PURE__ */ jsxs(Text, {
-							dimColor: true,
-							children: [
-								"Active Pages ",
-								/* @__PURE__ */ jsx(Text, {
-									color: "gray",
-									children: "(↑↓ select, x kill, K kill all)"
-								}),
-								":"
-							]
-						}), allPages.map((page, i) => {
-							const isSelected = i === selectedIndex;
-							const modelName = page.modelId || "loading...";
-							const shortName = modelName.length > 30 ? `...${modelName.slice(-27)}` : modelName;
-							return /* @__PURE__ */ jsxs(Box, {
-								flexDirection: "column",
-								marginLeft: 1,
-								children: [/* @__PURE__ */ jsxs(Text, { children: [
-									/* @__PURE__ */ jsxs(Text, {
-										color: "gray",
-										children: [i + 1, "."]
-									}),
-									" ",
-									/* @__PURE__ */ jsx(Text, {
-										color: isSelected ? "cyan" : page.isOurs ? "green" : "yellow",
-										children: isSelected ? "▶" : page.isOurs ? "●" : "○"
-									}),
-									" ",
-									/* @__PURE__ */ jsx(Text, {
-										bold: isSelected,
-										inverse: isSelected,
-										children: shortName
-									}),
-									page.isOurs ? /* @__PURE__ */ jsxs(Text, {
-										color: "green",
-										dimColor: true,
-										children: [" ", "(this session)"]
-									}) : /* @__PURE__ */ jsxs(Text, {
-										color: "yellow",
-										dimColor: true,
-										children: [" ", "(other session)"]
-									})
-								] }), page.memory && /* @__PURE__ */ jsxs(Text, {
-									dimColor: true,
-									children: [
-										"   ",
-										"Heap: ",
-										page.memory.usedGB.toFixed(2),
-										"GB used of",
-										" ",
-										page.memory.totalGB.toFixed(2),
-										"GB"
-									]
-								})]
-							}, i);
-						})]
-					}),
-					totalPageCount === 0 && webgpuInfo.browser.running && /* @__PURE__ */ jsx(Text, {
-						color: "yellow",
-						dimColor: true,
-						children: "⚠ No active pages (zombie browser?) - press K to kill"
-					}),
-					killing && /* @__PURE__ */ jsx(Box, {
-						marginTop: 1,
-						children: /* @__PURE__ */ jsx(Text, {
-							color: "cyan",
-							children: "Killing..."
-						})
-					}),
-					killResult && /* @__PURE__ */ jsx(Box, {
-						marginTop: 1,
-						children: /* @__PURE__ */ jsx(Text, {
-							color: "cyan",
-							children: killResult
-						})
-					})
-				]
+					]
+				})]
 			}),
 			/* @__PURE__ */ jsxs(Box, {
 				borderColor: "gray",
@@ -5236,36 +4742,6 @@ function InfoView({ gerbil, model, modelFamily, stats, onGoToCache }) {
 							children: "c"
 						}),
 						" cache | ",
-						/* @__PURE__ */ jsx(Text, {
-							color: "cyan",
-							children: "r"
-						}),
-						" refresh",
-						allPages.length > 0 && /* @__PURE__ */ jsxs(Fragment, { children: [
-							" ",
-							"| ",
-							/* @__PURE__ */ jsx(Text, {
-								color: "red",
-								children: "x"
-							}),
-							" kill selected | ",
-							/* @__PURE__ */ jsx(Text, {
-								color: "red",
-								children: "K"
-							}),
-							" kill all"
-						] }),
-						webgpuInfo?.browser.running && allPages.length === 0 && /* @__PURE__ */ jsxs(Fragment, { children: [
-							" ",
-							"| ",
-							/* @__PURE__ */ jsx(Text, {
-								color: "red",
-								children: "K"
-							}),
-							" kill browser"
-						] }),
-						"  ",
-						"| ",
 						/* @__PURE__ */ jsx(Text, {
 							color: "gray",
 							children: "Esc"
@@ -5354,6 +4830,29 @@ function formatContext(contextLength) {
 	if (contextLength >= 1e3) return `${(contextLength / 1e3).toFixed(0)}K`;
 	return `${contextLength}`;
 }
+/**
+* Read a model's config.json and decide whether the native WebGPU engine
+* currently supports its architecture. Uses the same `architectures` key the
+* loader reads, falling back to `model_type`. A model that is NOT supported can
+* still be selected and downloaded (discovery) — it just fails loudly at load
+* with a clear "Unsupported model architecture" message, and Gerbil may add
+* support for it later.
+*/
+async function detectNativeSupport(modelId) {
+	try {
+		const res = await fetch(`https://huggingface.co/${modelId}/raw/main/config.json`);
+		if (!res.ok) return { supported: false };
+		const config = await res.json();
+		const architecture = (Array.isArray(config.architectures) ? config.architectures[0] : void 0) || config.model_type;
+		if (!architecture) return { supported: false };
+		return {
+			architecture,
+			supported: isArchitectureSupported(architecture)
+		};
+	} catch {
+		return { supported: false };
+	}
+}
 const TTS_MODELS = [{
 	id: "kokoro-82m",
 	name: "Kokoro 82M",
@@ -5424,7 +4923,6 @@ function ModelView({ currentModel, onSelect, onDownloadOnly, onTabChange, onSear
 	const abortControllerRef = useRef(null);
 	const hasFetchedOnMountRef = useRef(false);
 	const refreshCachedModels = async () => {
-		await refreshCachedModelSizes().catch(() => {});
 		const cached = /* @__PURE__ */ new Set();
 		for (const model of PRESET_MODELS) if (isModelCached(model.hfId)) cached.add(model.id);
 		setCachedModels(cached);
@@ -5487,10 +4985,14 @@ function ModelView({ currentModel, onSelect, onDownloadOnly, onTabChange, onSear
 				params = p.BF16 || p.F16 || p.F32 || info.safetensors.total || 0;
 			}
 			const metadata = await fetchModelMetadata(modelId);
+			const sizeBytes = metadata.sizeBytes || info.usedStorage || 0;
+			const { architecture, supported } = await detectNativeSupport(modelId);
 			return {
-				sizeBytes: metadata.sizeBytes || info.usedStorage || 0,
+				sizeBytes,
 				params,
-				contextLength: metadata.contextLength
+				contextLength: metadata.contextLength,
+				architecture,
+				supported
 			};
 		} catch {
 			return null;
@@ -5508,6 +5010,8 @@ function ModelView({ currentModel, onSelect, onDownloadOnly, onTabChange, onSear
 					sizeBytes: result.sizeBytes,
 					params: result.params,
 					contextLength: result.contextLength,
+					architecture: result.architecture,
+					supported: result.supported,
 					loading: false
 				};
 				else if (updatedModels[modelIdx]) updatedModels[modelIdx] = {
@@ -5517,6 +5021,12 @@ function ModelView({ currentModel, onSelect, onDownloadOnly, onTabChange, onSear
 			});
 			setHfModels([...updatedModels]);
 		}
+		const detected = updatedModels.filter((m) => m.supported !== void 0);
+		if (detected.length > 0 && process.env.GERBIL_DEBUG) {
+			const unsupported = detected.filter((m) => m.supported === false).length;
+			const pct = Math.round(unsupported / detected.length * 100);
+			console.error(`[discovery] ${unsupported}/${detected.length} (${pct}%) sampled HF models are outside the native architecture whitelist`);
+		}
 	};
 	const fetchHFModels = async (query, append = false, sort = sortMode) => {
 		if (hfLoading) return;
@@ -5527,16 +5037,16 @@ function ModelView({ currentModel, onSelect, onDownloadOnly, onTabChange, onSear
 		try {
 			const offset = append ? hfModels.length : 0;
 			const params = new URLSearchParams({
-				filter: "onnx",
+				filter: "text-generation",
+				library: "safetensors",
 				sort: "downloads",
 				direction: "-1",
 				limit: String(PAGE_SIZE * 2)
 			});
 			if (query) {
 				const searchTerms = query.split(",").map((t) => t.trim()).filter(Boolean);
-				if (!searchTerms.some((t) => t.toLowerCase().includes("onnx"))) searchTerms.push("onnx");
-				params.set("search", searchTerms.join(" "));
-			} else params.set("search", "onnx");
+				if (searchTerms.length > 0) params.set("search", searchTerms.join(" "));
+			}
 			if (offset > 0) params.set("skip", String(offset));
 			const res = await fetch(`https://huggingface.co/api/models?${params}`, { signal: abortControllerRef.current.signal });
 			if (!res.ok) throw new Error("API error");
@@ -5546,13 +5056,6 @@ function ModelView({ currentModel, onSelect, onDownloadOnly, onTabChange, onSear
 				const aDate = a.createdAt ? new Date(a.createdAt).getTime() : 0;
 				return (b.createdAt ? new Date(b.createdAt).getTime() : 0) - aDate;
 			});
-			sortedData.sort((a, b) => {
-				const aHasQuant = a.id.includes("q4f16") || a.id.includes("q4") || a.id.startsWith("onnx-community/");
-				const bHasQuant = b.id.includes("q4f16") || b.id.includes("q4") || b.id.startsWith("onnx-community/");
-				if (aHasQuant && !bHasQuant) return -1;
-				if (!aHasQuant && bHasQuant) return 1;
-				return 0;
-			});
 			const models = sortedData.map((m) => ({
 				id: m.id,
 				downloads: m.downloads || 0,
@@ -6164,7 +5667,7 @@ function ModelView({ currentModel, onSelect, onDownloadOnly, onTabChange, onSear
 					children: [/* @__PURE__ */ jsx(Spinner, { type: "dots" }), " "]
 				}), /* @__PURE__ */ jsx(Text, {
 					dimColor: true,
-					children: "Fetching ONNX models..."
+					children: "Fetching models..."
 				})] }),
 				hfError && /* @__PURE__ */ jsx(Text, {
 					color: "red",
@@ -6182,17 +5685,22 @@ function ModelView({ currentModel, onSelect, onDownloadOnly, onTabChange, onSear
 							/* @__PURE__ */ jsx(Text, {
 								bold: true,
 								dimColor: true,
-								children: "Model".padEnd(44)
+								children: "Model".padEnd(40)
 							}),
 							/* @__PURE__ */ jsx(Text, {
 								bold: true,
 								dimColor: true,
-								children: "Params".padStart(8)
+								children: "Engine".padEnd(13)
 							}),
 							/* @__PURE__ */ jsx(Text, {
 								bold: true,
 								dimColor: true,
-								children: "Size".padStart(10)
+								children: "Params".padStart(7)
+							}),
+							/* @__PURE__ */ jsx(Text, {
+								bold: true,
+								dimColor: true,
+								children: "Size".padStart(9)
 							}),
 							/* @__PURE__ */ jsx(Text, {
 								bold: true,
@@ -6202,7 +5710,7 @@ function ModelView({ currentModel, onSelect, onDownloadOnly, onTabChange, onSear
 							/* @__PURE__ */ jsx(Text, {
 								bold: true,
 								dimColor: true,
-								children: "Updated".padStart(10)
+								children: "Updated".padStart(9)
 							}),
 							/* @__PURE__ */ jsx(Text, {
 								bold: true,
@@ -6212,6 +5720,19 @@ function ModelView({ currentModel, onSelect, onDownloadOnly, onTabChange, onSear
 						] }),
 						filteredModels.map((model, i) => {
 							const isCached = isModelCached(model.id);
+							let badge;
+							if (model.loading || model.supported === void 0) badge = /* @__PURE__ */ jsx(Text, {
+								dimColor: true,
+								children: "…".padEnd(13)
+							});
+							else if (model.supported) badge = /* @__PURE__ */ jsx(Text, {
+								color: "green",
+								children: "native ✓".padEnd(13)
+							});
+							else badge = /* @__PURE__ */ jsx(Text, {
+								color: "yellow",
+								children: "unsupported".padEnd(13)
+							});
 							return /* @__PURE__ */ jsxs(Box, { children: [
 								/* @__PURE__ */ jsxs(Text, {
 									color: isCached ? "green" : "gray",
@@ -6219,15 +5740,16 @@ function ModelView({ currentModel, onSelect, onDownloadOnly, onTabChange, onSear
 								}),
 								/* @__PURE__ */ jsxs(Text, {
 									color: i === hfSelected ? "cyan" : "white",
-									children: [i === hfSelected ? "> " : "  ", model.id.length > 42 ? `${model.id.slice(0, 39)}...` : model.id.padEnd(42)]
+									children: [i === hfSelected ? "> " : "  ", model.id.length > 38 ? `${model.id.slice(0, 35)}...` : model.id.padEnd(38)]
 								}),
+								badge,
 								/* @__PURE__ */ jsx(Text, {
 									color: "yellow",
-									children: formatParams(model.params, model.id).padStart(8)
+									children: formatParams(model.params, model.id).padStart(7)
 								}),
 								/* @__PURE__ */ jsx(Text, {
 									color: "magenta",
-									children: (model.sizeBytes ? formatBytes(model.sizeBytes) : "-").padStart(10)
+									children: (model.sizeBytes ? formatBytes(model.sizeBytes) : "-").padStart(9)
 								}),
 								/* @__PURE__ */ jsx(Text, {
 									color: "cyan",
@@ -6235,7 +5757,7 @@ function ModelView({ currentModel, onSelect, onDownloadOnly, onTabChange, onSear
 								}),
 								/* @__PURE__ */ jsx(Text, {
 									dimColor: true,
-									children: formatDate(model.createdAt).padStart(10)
+									children: formatDate(model.createdAt).padStart(9)
 								}),
 								/* @__PURE__ */ jsx(Text, {
 									color: "gray",
@@ -6278,7 +5800,7 @@ function ModelView({ currentModel, onSelect, onDownloadOnly, onTabChange, onSear
 				}),
 				!hfLoading && hfModels.length === 0 && !hfError && /* @__PURE__ */ jsx(Text, {
 					dimColor: true,
-					children: "Loading ONNX models..."
+					children: "Loading models..."
 				})
 			] }),
 			tab === "voice" && /* @__PURE__ */ jsxs(Box, {
@@ -6950,7 +6472,7 @@ function SkillsView({ gerbil, onCreateNew, onSwitchModel }) {
 	const [skillsLoaded, setSkillsLoaded] = useState(false);
 	const [cachedModels, setCachedModels] = useState([]);
 	const [modelSelectIndex, setModelSelectIndex] = useState(0);
-	const [currentModel, setCurrentModel] = useState(gerbil.getModelInfo()?.id || "qwen3-0.6b");
+	const [currentModel, setCurrentModel] = useState(gerbil.getModelInfo()?.id || DEFAULT_MODEL);
 	const [attachedImage, setAttachedImage] = useState(null);
 	const [attachedImageName, setAttachedImageName] = useState(null);
 	const [imageError, setImageError] = useState(null);
@@ -8040,20 +7562,20 @@ function getViewPrompt(view, ctx = {}) {
 	}
 }
 getViewPrompt("chat"), getViewPrompt("skills"), getViewPrompt("create-skill"), getViewPrompt("code");
-function App({ initialView = "menu", forcedDevice } = {}) {
+function App({ initialView = "menu" } = {}) {
 	const { exit } = useApp();
 	const gerbilRef = useRef(null);
 	const [state, setState] = useState({
 		view: "menu",
 		gerbil: null,
-		model: "qwen3-0.6b",
+		model: DEFAULT_MODEL,
 		loading: true,
 		loadingMessage: "Loading model...",
 		thinkingMode: false,
 		agentMode: true,
 		voiceMode: false,
 		downloadStatus: "",
-		deviceMode: forcedDevice ?? (process.env.GERBIL_CPU === "1" ? "cpu" : "webgpu"),
+		deviceMode: "webgpu",
 		ttsModel: "kokoro-82m",
 		sttModel: "whisper-tiny.en"
 	});
@@ -8137,9 +7659,8 @@ function App({ initialView = "menu", forcedDevice } = {}) {
 		const loadModel = async () => {
 			const g = new Gerbil();
 			try {
-				const device = state.deviceMode;
 				await g.loadModel(state.model, {
-					device,
+					device: "webgpu",
 					onProgress: (p) => {
 						if (!mounted) return;
 						if (p.status?.includes("Unable to determine content-length")) return;
@@ -8166,8 +7687,7 @@ function App({ initialView = "menu", forcedDevice } = {}) {
 					view: pendingView || "menu"
 				}));
 				if (pendingView) setPendingView(null);
-				if (g.getDeviceMode() === "webgpu") setTimeout(() => generateWelcome(g).catch(() => {}), 1500);
-				else generateWelcome(g).catch(() => {});
+				setTimeout(() => generateWelcome(g).catch(() => {}), 1500);
 			} catch (error) {
 				if (!mounted) return;
 				setState((s) => ({
@@ -8181,7 +7701,7 @@ function App({ initialView = "menu", forcedDevice } = {}) {
 		return () => {
 			mounted = false;
 			if (gerbilRef.current) {
-				import("./repl-DveXw36T.mjs").then(({ setCleanupPromise: setCleanupPromise$1 }) => {
+				import("./repl-BDRkwPGX.mjs").then(({ setCleanupPromise: setCleanupPromise$1 }) => {
 					setCleanupPromise$1(gerbilRef.current?.dispose(true) ?? Promise.resolve());
 				});
 				gerbilRef.current = null;
@@ -8271,49 +7791,6 @@ function App({ initialView = "menu", forcedDevice } = {}) {
 			return () => clearTimeout(timer);
 		}
 	}, [ctrlCPressed]);
-	const handleDeviceSwitch = async (newDevice) => {
-		if (newDevice === state.deviceMode) return;
-		setState((s) => ({
-			...s,
-			deviceMode: newDevice,
-			loading: true,
-			loadingMessage: `Switching to ${newDevice.toUpperCase()}...`
-		}));
-		if (gerbilRef.current) {
-			await gerbilRef.current.dispose();
-			gerbilRef.current = null;
-		}
-		const g = new Gerbil();
-		try {
-			await g.loadModel(state.model, {
-				device: newDevice,
-				onProgress: (p) => {
-					if (p.status?.includes("Unable to determine content-length")) return;
-					setState((s) => ({
-						...s,
-						loadingMessage: p.file ? `${p.file} ${p.progress || 0}%` : p.status
-					}));
-				}
-			});
-			const supportsThinking = g.getModelInfo()?.supportsThinking ?? false;
-			setToolContext({ generate: async (prompt) => {
-				return (await g.generate(prompt, { maxTokens: 200 })).text;
-			} });
-			gerbilRef.current = g;
-			setState((s) => ({
-				...s,
-				gerbil: g,
-				loading: false,
-				thinkingMode: supportsThinking
-			}));
-		} catch (error) {
-			setState((s) => ({
-				...s,
-				loading: false,
-				loadingMessage: `Error: ${error}`
-			}));
-		}
-	};
 	useInput((input, key) => {
 		if (key.ctrl && input === "c") {
 			if (ctrlCPressed) exit();
@@ -8432,7 +7909,6 @@ function App({ initialView = "menu", forcedDevice } = {}) {
 			...s,
 			voiceMode: !s.voiceMode
 		}));
-		if ((input === "m" || input === "M") && state.view === "menu" && !state.loading) handleDeviceSwitch(state.deviceMode === "webgpu" ? "cpu" : "webgpu");
 	});
 	if (state.loading) return /* @__PURE__ */ jsx(LoadingView, { message: state.loadingMessage });
 	if (state.view === "menu") return /* @__PURE__ */ jsxs(Box, {
@@ -8486,8 +7962,8 @@ function App({ initialView = "menu", forcedDevice } = {}) {
 					}),
 					/* @__PURE__ */ jsx(Text, {
 						bold: true,
-						color: state.gerbil?.getDeviceMode() === "webgpu" ? "green" : "yellow",
-						children: state.gerbil?.getDeviceMode()?.toUpperCase() || "CPU"
+						color: "green",
+						children: (state.gerbil?.getDeviceMode() ?? "webgpu").toUpperCase()
 					}),
 					state.gerbil?.getModelInfo()?.supportsThinking ? /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(Text, {
 						dimColor: true,
@@ -8608,14 +8084,6 @@ function App({ initialView = "menu", forcedDevice } = {}) {
 						dimColor: true,
 						children: "oice · "
 					}),
-					/* @__PURE__ */ jsx(Text, {
-						color: "cyan",
-						children: "m"
-					}),
-					/* @__PURE__ */ jsx(Text, {
-						dimColor: true,
-						children: "ode · "
-					}),
 					/* @__PURE__ */ jsx(Text, {
 						color: "blue",
 						children: "d"
@@ -8652,13 +8120,11 @@ function App({ initialView = "menu", forcedDevice } = {}) {
 			}) : null
 		]
 	});
-	const handleModelSelect = async (model, deviceOverride) => {
+	const handleModelSelect = async (model) => {
 		const returnView = returnToBenchmark ? "benchmark" : "menu";
-		const newDevice = deviceOverride ?? state.deviceMode;
 		setState((s) => ({
 			...s,
 			model,
-			deviceMode: newDevice,
 			view: returnView,
 			loading: true,
 			loadingMessage: "Switching model..."
@@ -8671,7 +8137,7 @@ function App({ initialView = "menu", forcedDevice } = {}) {
 		const g = new Gerbil();
 		try {
 			await g.loadModel(model, {
-				device: newDevice,
+				device: "webgpu",
 				onProgress: (p) => {
 					if (p.status?.includes("Unable to determine content-length")) return;
 					setState((s) => ({
@@ -8706,15 +8172,23 @@ function App({ initialView = "menu", forcedDevice } = {}) {
 			downloadStatus: `Downloading ${modelId}...`
 		}));
 		const tempGerbil = new Gerbil();
+		let initTimer = null;
 		try {
 			await tempGerbil.loadModel(modelId, { onProgress: (p) => {
 				if (p.status?.includes("Unable to determine content-length")) return;
+				if (initTimer) clearTimeout(initTimer);
 				setState((s) => ({
 					...s,
 					downloadStatus: p.file ? `${p.file} ${p.progress || 0}%` : p.status || ""
 				}));
+				initTimer = setTimeout(() => {
+					setState((s) => ({
+						...s,
+						downloadStatus: `Initializing ${modelId}...`
+					}));
+				}, 600);
 			} });
-			await tempGerbil.dispose();
+			if (initTimer) clearTimeout(initTimer);
 			setState((s) => ({
 				...s,
 				downloadStatus: `[done] Downloaded ${modelId}`
@@ -8725,6 +8199,7 @@ function App({ initialView = "menu", forcedDevice } = {}) {
 			})), 2500);
 			return true;
 		} catch (error) {
+			if (initTimer) clearTimeout(initTimer);
 			setState((s) => ({
 				...s,
 				downloadStatus: `[error] ${error}`
@@ -8734,6 +8209,8 @@ function App({ initialView = "menu", forcedDevice } = {}) {
 				downloadStatus: ""
 			})), 3e3);
 			return false;
+		} finally {
+			await tempGerbil.dispose();
 		}
 	};
 	return /* @__PURE__ */ jsxs(Box, {
@@ -8973,7 +8450,6 @@ function App({ initialView = "menu", forcedDevice } = {}) {
 								setBenchmarkStatus(status);
 								setBenchmarkStatsState(stats);
 							},
-							onSwitchDevice: handleDeviceSwitch,
 							onSwitchModel: () => {
 								setReturnToBenchmark(true);
 								transitionToView("model");
@@ -9070,10 +8546,7 @@ async function startRepl(options) {
 	process.on("SIGINT", handleSignal);
 	process.on("SIGTERM", () => process.exit(0));
 	try {
-		const { waitUntilExit } = render(/* @__PURE__ */ jsx(App, {
-			forcedDevice: options?.forcedDevice,
-			initialView: options?.initialView
-		}));
+		const { waitUntilExit } = render(/* @__PURE__ */ jsx(App, { initialView: options?.initialView }));
 		await waitUntilExit();
 		if (pendingCleanup) try {
 			await Promise.race([pendingCleanup, new Promise((r) => setTimeout(r, 500))]);
@@ -9104,97 +8577,113 @@ async function startRepl(options) {
 */
 const program = new Command();
 program.name("gerbil").description("🐹 Local LLM inference for Node.js").version(version);
-program.argument("[prompt...]", "Prompt to generate from (opens REPL if empty)").option("-m, --model <id>", "Model to use", "qwen3-0.6b").option("-n, --max-tokens <n>", "Max tokens", "256").option("-t, --temperature <t>", "Temperature", "0.7").option("-s, --system <text>", "System prompt").option("--thinking", "Enable thinking mode").option("--stream", "Stream output").option("--json", "Output as JSON").action(async (promptParts, opts) => {
-	if (promptParts.length === 0) {
+program.command("generate [prompt...]", { isDefault: true }).alias("g").description("Generate text (opens the REPL when no prompt is given)").option("-m, --model <id>", "Model to use", DEFAULT_MODEL).option("-n, --max-tokens <n>", "Max tokens", "256").option("-t, --temperature <t>", "Temperature", "0.7").option("-s, --system <text>", "System prompt").option("--thinking", "Enable thinking mode").option("--stream", "Stream output").option("--json", "Output as JSON").action(async (promptParts, opts) => {
+	if (!promptParts || promptParts.length === 0) {
 		await startRepl({});
 		return;
 	}
 	await runGenerate(promptParts.join(" "), opts);
 });
-program.command("generate <prompt...>").alias("g").description("Generate text").option("-m, --model <id>", "Model to use", "qwen3-0.6b").option("-n, --max-tokens <n>", "Max tokens", "256").option("-t, --temperature <t>", "Temperature", "0.7").option("-s, --system <text>", "System prompt").option("--thinking", "Enable thinking mode").option("--stream", "Stream output").option("--json", "Output as JSON").action(async (promptParts, opts) => {
-	await runGenerate(promptParts.join(" "), opts);
-});
 async function runGenerate(prompt, opts) {
 	const g = new Gerbil();
 	const spinner = ora(`Loading ${chalk.cyan(opts.model)}...`).start();
 	try {
-		await g.loadModel(opts.model, { onProgress: (p) => {
-			spinner.text = p.progress ? `${p.status} (${p.progress}%)` : p.status;
-		} });
+		await g.loadModel(opts.model, {
+			device: "webgpu",
+			onProgress: (p) => {
+				spinner.text = p.progress ? `${p.status} (${p.progress}%)` : p.status;
+			}
+		});
 		spinner.succeed("Model loaded");
-		if (opts.thinking) {}
+		const genOpts = {
+			maxTokens: Number.parseInt(opts.maxTokens, 10),
+			temperature: Number.parseFloat(opts.temperature),
+			system: opts.system,
+			thinking: opts.thinking
+		};
 		if (opts.stream) {
 			process.stdout.write(chalk.green("Response: "));
-			for await (const chunk of g.stream(prompt, {
-				maxTokens: Number.parseInt(opts.maxTokens, 10),
-				temperature: Number.parseFloat(opts.temperature),
-				system: opts.system,
-				thinking: opts.thinking
-			})) process.stdout.write(chunk);
+			for await (const chunk of g.stream(prompt, genOpts)) process.stdout.write(chunk);
+			process.stdout.write("\n");
 		} else {
 			const genSpinner = ora("Generating...").start();
-			const result = await g.generate(prompt, {
-				maxTokens: Number.parseInt(opts.maxTokens, 10),
-				temperature: Number.parseFloat(opts.temperature),
-				system: opts.system,
-				thinking: opts.thinking
-			});
+			const result = await g.generate(prompt, genOpts);
 			genSpinner.stop();
-			if (opts.json) {} else if (result.thinking) {}
+			if (opts.json) console.log(JSON.stringify(result, null, 2));
+			else {
+				if (opts.thinking && result.thinking) console.log(chalk.gray(`\n[thinking]\n${result.thinking}\n`));
+				console.log(result.text);
+				console.log(chalk.gray(`\n${result.tokensGenerated} tokens · ${result.tokensPerSecond.toFixed(1)} tok/s`));
+			}
 		}
 		await g.dispose();
-	} catch (_e) {
-		spinner.fail("Error");
+	} catch (e) {
+		spinner.fail(`Error: ${e?.message ?? e}`);
 		process.exit(1);
 	}
 }
-program.command("repl").alias("r").description("Interactive TUI with chat, skills, and more").option("--cpu", "Force CPU inference mode").option("--gpu", "Force GPU/WebGPU inference mode").action(async (opts) => {
-	await startRepl({ forcedDevice: opts.cpu ? "cpu" : opts.gpu ? "webgpu" : void 0 });
+program.command("object <prompt...>").alias("obj").description("Generate a structured JSON object (with optional schema validation)").option("-m, --model <id>", "Model to use", DEFAULT_MODEL).option("-n, --max-tokens <n>", "Max tokens", "512").option("-t, --temperature <t>", "Temperature", "0.3").option("--schema <file>", "Path to a JSON file with a { required: string[] } shape to validate against").option("--retries <n>", "Max retries after the first attempt", "4").action(async (promptParts, opts) => {
+	const g = new Gerbil();
+	const spinner = ora(`Loading ${chalk.cyan(opts.model)}...`).start();
+	try {
+		let schema;
+		if (opts.schema) {
+			const fs$1 = await import("node:fs");
+			schema = JSON.parse(fs$1.readFileSync(opts.schema, "utf-8"));
+		}
+		await g.loadModel(opts.model, {
+			device: "webgpu",
+			onProgress: (p) => {
+				spinner.text = p.progress ? `${p.status} (${p.progress}%)` : p.status;
+			}
+		});
+		spinner.succeed("Model loaded");
+		const genSpinner = ora("Generating object...").start();
+		const result = await g.generateObject(promptParts.join(" "), {
+			schema,
+			maxRetries: Number.parseInt(opts.retries, 10),
+			maxTokens: Number.parseInt(opts.maxTokens, 10),
+			sampling: { temperature: Number.parseFloat(opts.temperature) }
+		});
+		genSpinner.stop();
+		console.log(JSON.stringify(result.object, null, 2));
+		console.log(chalk.gray(`\n${result.attempts} attempt(s)`));
+		await g.dispose();
+	} catch (e) {
+		spinner.fail(`Error: ${e?.message ?? e}`);
+		process.exit(1);
+	}
 });
-program.command("chat").alias("c").description("Interactive chat (opens REPL chat view)").option("--cpu", "Force CPU inference mode").option("--gpu", "Force GPU/WebGPU inference mode").action(async (opts) => {
-	await startRepl({
-		initialView: "chat",
-		forcedDevice: opts.cpu ? "cpu" : opts.gpu ? "webgpu" : void 0
-	});
+program.command("repl").alias("r").description("Interactive TUI with chat, skills, and more").action(async () => {
+	await startRepl({});
 });
-program.command("skills").description("Open REPL skills view").option("--cpu", "Force CPU inference mode").option("--gpu", "Force GPU/WebGPU inference mode").action(async (opts) => {
-	await startRepl({
-		initialView: "skills",
-		forcedDevice: opts.cpu ? "cpu" : opts.gpu ? "webgpu" : void 0
-	});
+program.command("chat").alias("c").description("Interactive chat (opens REPL chat view)").action(async () => {
+	await startRepl({ initialView: "chat" });
 });
-program.command("tools").description("Open REPL tools view").option("--cpu", "Force CPU inference mode").option("--gpu", "Force GPU/WebGPU inference mode").action(async (opts) => {
-	await startRepl({
-		initialView: "tools",
-		forcedDevice: opts.cpu ? "cpu" : opts.gpu ? "webgpu" : void 0
-	});
+program.command("skills").description("Open REPL skills view").action(async () => {
+	await startRepl({ initialView: "skills" });
 });
-program.command("model").description("Open REPL model view").option("--cpu", "Force CPU inference mode").option("--gpu", "Force GPU/WebGPU inference mode").action(async (opts) => {
-	await startRepl({
-		initialView: "model",
-		forcedDevice: opts.cpu ? "cpu" : opts.gpu ? "webgpu" : void 0
-	});
+program.command("tools").description("Open REPL tools view").action(async () => {
+	await startRepl({ initialView: "tools" });
 });
-program.command("integrate").description("Open REPL framework integration view").option("--cpu", "Force CPU inference mode").option("--gpu", "Force GPU/WebGPU inference mode").action(async (opts) => {
-	await startRepl({
-		initialView: "frameworks",
-		forcedDevice: opts.cpu ? "cpu" : opts.gpu ? "webgpu" : void 0
-	});
+program.command("model").description("Open REPL model view").action(async () => {
+	await startRepl({ initialView: "model" });
 });
-program.command("benchmark").description("Open REPL benchmark view").option("--cpu", "Force CPU inference mode").option("--gpu", "Force GPU/WebGPU inference mode").action(async (opts) => {
-	await startRepl({
-		initialView: "benchmark",
-		forcedDevice: opts.cpu ? "cpu" : opts.gpu ? "webgpu" : void 0
-	});
+program.command("integrate").description("Open REPL framework integration view").action(async () => {
+	await startRepl({ initialView: "frameworks" });
+});
+program.command("benchmark").description("Open REPL benchmark view").action(async () => {
+	await startRepl({ initialView: "benchmark" });
 });
 program.command("commit").description("Generate commit message from staged changes").option("--type <type>", "Commit style: conventional, simple, detailed", "conventional").option("--write", "Write message to .git/COMMIT_EDITMSG").action(async (opts) => {
 	const spinner = ora("Generating commit message...").start();
 	try {
 		const message = await commit({ type: opts.type });
 		spinner.stop();
+		console.log(message);
 		if (opts.write) (await import("node:fs")).writeFileSync(".git/COMMIT_EDITMSG", message);
-	} catch (_e) {
-		spinner.fail("Error");
+	} catch (e) {
+		spinner.fail(`Error: ${e?.message ?? e}`);
 		process.exit(1);
 	}
 });
@@ -9202,14 +8691,15 @@ program.command("summarize <file>").description("Summarize a file").option("-l,
 	const content = (await import("node:fs")).readFileSync(file, "utf-8");
 	const spinner = ora("Summarizing...").start();
 	try {
-		await summarize({
+		const summary = await summarize({
 			content,
 			length: opts.length,
 			format: opts.format
 		});
 		spinner.stop();
-	} catch (_e) {
-		spinner.fail("Error");
+		console.log(summary);
+	} catch (e) {
+		spinner.fail(`Error: ${e?.message ?? e}`);
 		process.exit(1);
 	}
 });
@@ -9217,13 +8707,14 @@ program.command("explain <file>").description("Explain code").option("-l, --leve
 	const content = (await import("node:fs")).readFileSync(file, "utf-8");
 	const spinner = ora("Explaining...").start();
 	try {
-		await explain({
+		const explanation = await explain({
 			content,
 			level: opts.level
 		});
 		spinner.stop();
-	} catch (_e) {
-		spinner.fail("Error");
+		console.log(explanation);
+	} catch (e) {
+		spinner.fail(`Error: ${e?.message ?? e}`);
 		process.exit(1);
 	}
 });
@@ -9232,13 +8723,14 @@ program.command("review <file>").description("Review code").option("-f, --focus
 	const spinner = ora("Reviewing...").start();
 	try {
 		const focus = opts.focus === "all" ? ["all"] : opts.focus.split(",");
-		await review({
+		const reviewResult = await review({
 			code: content,
 			focus
 		});
 		spinner.stop();
-	} catch (_e) {
-		spinner.fail("Error");
+		console.log(reviewResult);
+	} catch (e) {
+		spinner.fail(`Error: ${e?.message ?? e}`);
 		process.exit(1);
 	}
 });
@@ -9324,19 +8816,19 @@ program.command("speak [text...]").description("Convert text to speech using loc
 		process.exit(1);
 	}
 });
-program.command("voice [audio]").description("Voice conversation: transcribe audio, generate response, speak it back").option("-m, --model <model>", "LLM model to use", "qwen3-0.6b").option("-s, --stt-model <model>", "STT model ID", "whisper-tiny.en").option("-v, --voice <voice>", "TTS voice ID", "af_heart").option("--system <prompt>", "System prompt", "You are a helpful voice assistant. Keep responses brief and conversational.").option("--thinking", "Enable thinking mode").action(async (audioFile, opts) => {
+program.command("voice [audio]").description("Voice conversation: transcribe audio, generate response, speak it back").option("-m, --model <model>", "LLM model to use", DEFAULT_MODEL).option("-s, --stt-model <model>", "STT model ID", "whisper-tiny.en").option("-v, --voice <voice>", "TTS voice ID", "af_heart").option("--system <prompt>", "System prompt", "You are a helpful voice assistant. Keep responses brief and conversational.").option("--thinking", "Enable thinking mode").action(async (audioFile, opts) => {
 	if (!audioFile) {
 		console.log(chalk.cyan("\n🎙️  Gerbil Voice Chat\n"));
 		console.log(chalk.yellow("Usage: gerbil voice <audio.wav> [options]\n"));
 		console.log("Options:");
-		console.log("  -m, --model <model>      LLM model (default: qwen3-0.6b)");
+		console.log(`  -m, --model <model>      LLM model (default: ${DEFAULT_MODEL})`);
 		console.log("  -s, --stt-model <model>  STT model (default: whisper-tiny.en)");
 		console.log("  -v, --voice <voice>      TTS voice (default: af_heart)");
 		console.log("  --system <prompt>        System prompt");
 		console.log("  --thinking               Enable thinking mode");
 		console.log("\nExample:");
 		console.log(chalk.gray("  gerbil voice question.wav --voice bf_emma"));
-		console.log(chalk.gray("  gerbil voice \"what time is it.wav\" --model qwen3-1.7b\n"));
+		console.log(chalk.gray("  gerbil voice \"what time is it.wav\" --model qwen3.5-2b\n"));
 		return;
 	}
 	const g = new Gerbil();
@@ -9498,29 +8990,26 @@ function audioToWav(audio, sampleRate) {
 	}
 	return buffer;
 }
-program.command("serve").description("Start Gerbil server (use --mcp or --http for CLI, otherwise opens REPL)").option("-m, --model <id>", "Model to use", "qwen3-0.6b").option("-p, --port <port>", "HTTP port", "3000").option("--mcp", "Start MCP server (stdio)").option("--http", "Start HTTP server (CLI mode)").option("--cpu", "Force CPU inference mode").option("--gpu", "Force GPU/WebGPU inference mode").action(async (opts) => {
+program.command("serve").description("Start Gerbil server (use --mcp or --http for CLI, otherwise opens REPL)").option("-m, --model <id>", "Model to use", DEFAULT_MODEL).option("-p, --port <port>", "HTTP port", "3000").option("--mcp", "Start MCP server (stdio)").option("--http", "Start HTTP server (CLI mode)").action(async (opts) => {
 	if (!(opts.mcp || opts.http)) {
-		await startRepl({
-			initialView: "serve",
-			forcedDevice: opts.cpu ? "cpu" : opts.gpu ? "webgpu" : void 0
-		});
+		await startRepl({ initialView: "serve" });
 		return;
 	}
 	if (opts.mcp) await startMCPServer({ model: opts.model });
 	else {
-		const { Gerbil: Gerbil$1 } = await import("./gerbil-CJ3ifloF.mjs");
+		const { Gerbil: Gerbil$1 } = await import("./gerbil-CTZUa8EZ.mjs");
 		const g = new Gerbil$1();
 		const spinner = ora("Loading model...").start();
 		await g.loadModel(opts.model);
 		spinner.succeed("Model loaded");
-		(await import("node:http")).createServer(async (req, res) => {
+		const server = (await import("node:http")).createServer(async (req, res) => {
 			if (req.method === "POST" && req.url === "/generate") {
 				let body = "";
 				req.on("data", (chunk) => body += chunk);
 				req.on("end", async () => {
 					try {
-						const { prompt, ...opts$1 } = JSON.parse(body);
-						const result = await g.generate(prompt, opts$1);
+						const { prompt, ...genOpts } = JSON.parse(body);
+						const result = await g.generate(prompt, genOpts);
 						res.writeHead(200, { "Content-Type": "application/json" });
 						res.end(JSON.stringify(result));
 					} catch (e) {
@@ -9528,6 +9017,25 @@ program.command("serve").description("Start Gerbil server (use --mcp or --http f
 						res.end(JSON.stringify({ error: String(e) }));
 					}
 				});
+			} else if (req.method === "POST" && req.url === "/stream") {
+				let body = "";
+				req.on("data", (chunk) => body += chunk);
+				req.on("end", async () => {
+					try {
+						const { prompt, ...genOpts } = JSON.parse(body);
+						res.writeHead(200, {
+							"Content-Type": "text/event-stream",
+							"Cache-Control": "no-cache",
+							Connection: "keep-alive"
+						});
+						for await (const token of g.stream(prompt, genOpts)) res.write(`data: ${JSON.stringify({ token })}\n\n`);
+						res.write("data: [DONE]\n\n");
+						res.end();
+					} catch (e) {
+						res.write(`data: ${JSON.stringify({ error: String(e) })}\n\n`);
+						res.end();
+					}
+				});
 			} else if (req.method === "GET" && req.url === "/info") {
 				res.writeHead(200, { "Content-Type": "application/json" });
 				res.end(JSON.stringify(g.getInfo()));
@@ -9535,7 +9043,14 @@ program.command("serve").description("Start Gerbil server (use --mcp or --http f
 				res.writeHead(404);
 				res.end("Not found");
 			}
-		}).listen(Number.parseInt(opts.port, 10), () => {});
+		});
+		const port = Number.parseInt(opts.port, 10);
+		server.listen(port, () => {
+			console.log(chalk.green(`\nHTTP server on http://localhost:${port}`));
+			console.log(chalk.gray("  POST /generate  { prompt, ...options }"));
+			console.log(chalk.gray("  POST /stream    { prompt, ...options }  (SSE)"));
+			console.log(chalk.gray("  GET  /info"));
+		});
 	}
 });
 program.command("models").description("List available models").option("--search <query>", "Search models").action(async (opts) => {
@@ -9544,38 +9059,61 @@ program.command("models").description("List available models").option("--search
 		const q = opts.search.toLowerCase();
 		models = models.filter((m) => m.id.toLowerCase().includes(q) || m.description.toLowerCase().includes(q));
 	}
-	for (const m of models) if (m.supportsThinking) {}
+	console.log(chalk.cyan("\nBuilt-in models (native WebGPU engine):\n"));
+	for (const m of models) {
+		const flags = [
+			m.supportsThinking ? chalk.magenta("thinking") : null,
+			m.supportsJson ? chalk.blue("json") : null,
+			m.supportsVision ? chalk.green("vision") : null
+		].filter(Boolean).join(" ");
+		console.log(`  ${chalk.green(m.id.padEnd(22))} ${chalk.gray((m.size || "").padStart(7))}  ${m.description}`);
+		if (flags) console.log(`  ${" ".repeat(22)} ${flags}`);
+	}
+	console.log(chalk.gray("\nUse any HuggingFace repo with a supported architecture via hf:org/model.\n"));
 });
-program.command("info").description("Show system and model info (use --cli for text output, otherwise opens REPL)").option("-m, --model <id>", "Model to load and show info for", "qwen3-0.6b").option("--cli", "Output text info instead of opening REPL").option("--cpu", "Force CPU inference mode").option("--gpu", "Force GPU/WebGPU inference mode").action(async (opts) => {
+program.command("info").description("Show system and model info (use --cli for text output, otherwise opens REPL)").option("-m, --model <id>", "Model to load and show info for", DEFAULT_MODEL).option("--cli", "Output text info instead of opening REPL").action(async (opts) => {
 	if (!opts.cli) {
-		await startRepl({
-			initialView: "info",
-			forcedDevice: opts.cpu ? "cpu" : opts.gpu ? "webgpu" : void 0
-		});
+		await startRepl({ initialView: "info" });
 		return;
 	}
 	const g = new Gerbil();
 	const spinner = ora(`Loading ${chalk.cyan(opts.model)}...`).start();
 	try {
-		await g.loadModel(opts.model, { onProgress: (p) => {
-			spinner.text = p.progress ? `${p.status} (${p.progress}%)` : p.status;
-		} });
+		await g.loadModel(opts.model, {
+			device: "webgpu",
+			onProgress: (p) => {
+				spinner.text = p.progress ? `${p.status} (${p.progress}%)` : p.status;
+			}
+		});
 		spinner.stop();
-		g.getInfo();
+		const info = g.getInfo();
+		const deviceMode = g.getDeviceMode();
+		const deviceLabel = deviceMode === "webgpu" ? `${deviceMode.toUpperCase()} (Dawn)` : deviceMode.toUpperCase();
+		console.log(chalk.cyan("\nSystem Info\n"));
+		console.log(`  Backend:  ${chalk.green(info.device.backend)}`);
+		console.log(`  Device:   ${chalk.green(deviceLabel)}`);
+		console.log(`  Model:    ${chalk.cyan(info.model?.id ?? opts.model)}`);
+		console.log(`  Family:   ${chalk.gray(info.model?.family ?? "unknown")}`);
+		console.log(`  Dtype:    ${chalk.gray(g.getDtype())} (INT4 weights)`);
+		console.log(`  Context:  ${chalk.gray(info.context.max.toLocaleString())} tokens`);
+		console.log(`  Thinking: ${info.model?.supportsThinking ? chalk.magenta("yes") : "no"}`);
+		console.log(`  Cache:    ${chalk.gray(info.cache.location)}\n`);
 		await g.dispose();
-	} catch (_e) {
-		spinner.fail("Error loading model");
+	} catch (e) {
+		spinner.fail(`Error loading model: ${e?.message ?? e}`);
+		process.exit(1);
 	}
 });
 program.command("cache").description("Show or manage model cache").option("--clean", "Remove all cached models").option("--older-than <days>", "Remove models older than N days").action(async (opts) => {
 	const fs$1 = await import("node:fs");
 	const path$1 = await import("node:path");
 	const os$1 = await import("node:os");
-	const nodeModulesCache = path$1.join(process.cwd(), "node_modules", "@huggingface", "transformers", ".cache");
-	const cacheDir = fs$1.existsSync(nodeModulesCache) ? nodeModulesCache : process.env.HF_HOME || process.env.TRANSFORMERS_CACHE || path$1.join(os$1.homedir(), ".cache", "huggingface", "hub");
+	const cacheDir = path$1.join(os$1.homedir(), ".cache", "gerbil");
 	try {
-		if (!fs$1.existsSync(cacheDir)) return;
-		const entries = fs$1.readdirSync(cacheDir);
+		if (!fs$1.existsSync(cacheDir)) {
+			console.log(chalk.gray("No native model cache found."));
+			return;
+		}
 		const models = [];
 		const getSize = (dir) => {
 			let total = 0;
@@ -9590,132 +9128,119 @@ program.command("cache").description("Show or manage model cache").option("--cle
 			} catch {}
 			return total;
 		};
-		for (const entry of entries) {
+		for (const entry of fs$1.readdirSync(cacheDir)) {
 			const entryPath = path$1.join(cacheDir, entry);
 			try {
 				const entryStat = fs$1.statSync(entryPath);
 				if (!entryStat.isDirectory()) continue;
-				if (entry.startsWith("models--")) {
-					const modelName = entry.replace("models--", "").replace("--", "/");
-					const size = getSize(entryPath);
-					models.push({
-						name: modelName,
-						size,
-						mtime: entryStat.mtime,
-						path: entryPath
-					});
-				} else {
-					const subEntries = fs$1.readdirSync(entryPath);
-					for (const subEntry of subEntries) {
-						const subPath = path$1.join(entryPath, subEntry);
-						try {
-							const subStat = fs$1.statSync(subPath);
-							if (subStat.isDirectory()) {
-								const modelName = `${entry}/${subEntry}`;
-								const size = getSize(subPath);
-								if (size > 0) models.push({
-									name: modelName,
-									size,
-									mtime: subStat.mtime,
-									path: subPath
-								});
-							}
-						} catch {}
-					}
-				}
+				const size = getSize(entryPath);
+				if (size > 0) models.push({
+					name: entry.replace(/_/g, "/"),
+					size,
+					mtime: entryStat.mtime,
+					path: entryPath
+				});
 			} catch {}
 		}
-		if (models.length === 0) return;
+		if (models.length === 0) {
+			console.log(chalk.gray("No cached models."));
+			return;
+		}
 		if (opts.clean || opts.olderThan) {
 			const daysThreshold = opts.olderThan ? Number.parseInt(opts.olderThan, 10) : 0;
 			const cutoffDate = /* @__PURE__ */ new Date(Date.now() - daysThreshold * 24 * 60 * 60 * 1e3);
 			let removed = 0;
-			let _removedSize = 0;
+			let removedSize = 0;
 			for (const model of models) if (opts.clean || model.mtime < cutoffDate) try {
 				fs$1.rmSync(model.path, {
 					recursive: true,
 					force: true
 				});
 				removed += 1;
-				_removedSize += model.size;
+				removedSize += model.size;
 			} catch (_e) {}
-			if (removed > 0) {}
+			if (removed > 0) console.log(chalk.green(`Removed ${removed} model(s), freed ${formatSize(removedSize)}`));
+			else console.log(chalk.gray("Nothing to remove."));
 			return;
 		}
-		let _totalSize = 0;
+		console.log(chalk.cyan(`\nNative model cache (${chalk.gray(cacheDir)})\n`));
+		let totalSize = 0;
 		for (const model of models.sort((a, b) => b.mtime.getTime() - a.mtime.getTime())) {
-			formatTimeAgo(model.mtime);
-			formatSize(model.size).padStart(8);
-			_totalSize += model.size;
+			const timeAgo = formatTimeAgo(model.mtime);
+			const sizeStr = formatSize(model.size).padStart(8);
+			totalSize += model.size;
+			console.log(`  ${model.name.padEnd(40)} ${chalk.gray(sizeStr)}  ${chalk.gray(timeAgo)}`);
 		}
+		console.log(chalk.cyan(`\nTotal: ${formatSize(totalSize)}\n`));
 	} catch (_e) {}
 });
 const formatSize = formatBytes;
-program.command("cleanup").description("Clean up zombie Chrome pages and free memory").option("--kill-browser", "Also kill the shared Chrome browser (forces restart on next use)").option("--force", "Force kill all Gerbil Chrome processes (use if --kill-browser fails)").action(async (opts) => {
-	const { ChromeGPUBackend } = await import("./chrome-backend-DIKYoWj-.mjs");
-	const { execSync: execSync$1 } = await import("node:child_process");
-	console.log(chalk.cyan("\nChecking Chrome backend status...\n"));
-	let orphanPids = [];
-	try {
-		orphanPids = execSync$1("ps aux | grep \"gerbil/chrome-cache\" | grep -v grep", { encoding: "utf-8" }).trim().split("\n").filter(Boolean).map((line) => {
-			const parts = line.trim().split(/\s+/);
-			return Number.parseInt(parts[1], 10);
-		});
-	} catch {}
-	if (opts.force && orphanPids.length > 0) {
-		const spinner = ora(`Force killing ${orphanPids.length} Gerbil Chrome processes...`).start();
+program.command("cleanup").description("Clean up the native model cache and free disk space").option("--all", "Remove every cached model (frees the most space)").action(async (opts) => {
+	const fs$1 = await import("node:fs");
+	const path$1 = await import("node:path");
+	const os$1 = await import("node:os");
+	const nativeCacheDir = path$1.join(os$1.homedir(), ".cache", "gerbil");
+	console.log(chalk.cyan("\nNative model cache\n"));
+	if (!fs$1.existsSync(nativeCacheDir)) {
+		console.log(chalk.gray("No native model cache found."));
+		console.log();
+		return;
+	}
+	const dirSize = (dir) => {
+		let total = 0;
 		try {
-			execSync$1("pkill -f \"gerbil/chrome-cache\"", { stdio: "ignore" });
-			spinner.succeed(`Force killed ${orphanPids.length} process(es)`);
+			for (const item of fs$1.readdirSync(dir)) {
+				const itemPath = path$1.join(dir, item);
+				const stat = fs$1.statSync(itemPath);
+				total += stat.isDirectory() ? dirSize(itemPath) : stat.size;
+			}
+		} catch {}
+		return total;
+	};
+	const entries = fs$1.readdirSync(nativeCacheDir).filter((entry) => {
+		try {
+			return fs$1.statSync(path$1.join(nativeCacheDir, entry)).isDirectory();
 		} catch {
-			spinner.fail("Failed to kill processes");
+			return false;
 		}
+	});
+	if (entries.length === 0) {
+		console.log(chalk.gray("No cached models."));
 		console.log();
 		return;
 	}
-	const status = ChromeGPUBackend.getGlobalBrowserStatus();
-	if (!status.running) {
-		if (orphanPids.length > 0) {
-			console.log(chalk.yellow(`Found ${orphanPids.length} orphan Chrome process(es) but no WS connection.`));
-			console.log(chalk.gray("Use --force to kill them: gerbil cleanup --force"));
-		} else console.log(chalk.gray("No Chrome backend running."));
-		return;
-	}
-	console.log(`Chrome PID: ${chalk.yellow(status.pid)}`);
-	console.log(`Server port: ${chalk.yellow(status.port)}`);
-	console.log(`Active pages: ${chalk.yellow(status.activePagesCount)}/${status.maxPages}`);
-	const pageInfo = await ChromeGPUBackend.getAllChromePages();
-	if (pageInfo.length > 0) {
-		console.log(chalk.cyan("\nGerbil pages:"));
-		for (let i = 0; i < pageInfo.length; i++) {
-			const p = pageInfo[i];
-			const memStr = p.memory ? `${p.memory.usedGB.toFixed(2)}GB` : "?";
-			const owner = p.isOurs ? chalk.green("(this process)") : chalk.yellow("(orphan)");
-			console.log(`  [${i}] ${p.modelId || "unknown"} - ${memStr} ${owner}`);
-		}
+	console.log(`Location: ${chalk.gray(nativeCacheDir)}`);
+	let totalSize = 0;
+	for (const entry of entries) {
+		const size = dirSize(path$1.join(nativeCacheDir, entry));
+		totalSize += size;
+		console.log(`  ${entry.replace(/_/g, "/")} ${chalk.gray(formatSize(size).padStart(10))}`);
 	}
-	if (opts.killBrowser) {
-		const spinner = ora("Killing Chrome browser...").start();
-		const result = await ChromeGPUBackend.killAllBackends();
-		spinner.succeed(`Killed ${result.pagesKilled} page(s)${result.browserKilled ? " and browser" : ""}`);
-	} else {
-		const spinner = ora("Cleaning up orphan pages...").start();
-		let cleaned = 0;
-		for (let i = pageInfo.length - 1; i >= 0; i--) if (!pageInfo[i].isOurs) {
-			if (await ChromeGPUBackend.killPageByIndex(i)) cleaned++;
+	console.log(chalk.cyan(`\nTotal: ${formatSize(totalSize)}\n`));
+	if (opts.all) {
+		const spinner = ora("Removing all cached models...").start();
+		try {
+			fs$1.rmSync(nativeCacheDir, {
+				recursive: true,
+				force: true
+			});
+			spinner.succeed(`Removed ${entries.length} model(s), freed ${formatSize(totalSize)}`);
+		} catch (e) {
+			spinner.fail(`Failed to remove cache: ${e.message}`);
 		}
-		if (cleaned > 0) spinner.succeed(`Cleaned up ${cleaned} orphan page(s)`);
-		else spinner.info("No orphan pages to clean up");
-	}
+	} else console.log(chalk.gray("Use --all to remove every cached model."));
 	console.log();
 });
-program.command("bench").description("Benchmark model performance").option("-m, --model <id>", "Model to benchmark", "qwen3-0.6b").option("-n, --runs <n>", "Number of runs", "3").action(async (opts) => {
+program.command("bench").description("Benchmark model performance").option("-m, --model <id>", "Model to benchmark", DEFAULT_MODEL).option("-n, --runs <n>", "Number of runs", "3").action(async (opts) => {
 	const g = new Gerbil();
 	const spinner = ora(`Loading ${chalk.cyan(opts.model)}...`).start();
 	try {
-		await g.loadModel(opts.model, { onProgress: (p) => {
-			spinner.text = p.progress ? `${p.status} (${p.progress}%)` : p.status;
-		} });
+		await g.loadModel(opts.model, {
+			device: "webgpu",
+			onProgress: (p) => {
+				spinner.text = p.progress ? `${p.status} (${p.progress}%)` : p.status;
+			}
+		});
 		spinner.succeed("Model loaded");
 		const runs = Number.parseInt(opts.runs, 10);
 		const results = [];
@@ -9743,16 +9268,17 @@ program.command("bench").description("Benchmark model performance").option("-m,
 			});
 			runSpinner.succeed(`Run ${i + 1}: ${chalk.cyan(tokPerSec)} tok/s, ${chalk.yellow(`${firstTokenTime}ms`)} first token`);
 		}
-		Math.round(results.reduce((a, r) => a + r.tokPerSec, 0) / results.length);
-		Math.round(results.reduce((a, r) => a + r.firstToken, 0) / results.length);
+		const avgTokPerSec = Math.round(results.reduce((a, r) => a + r.tokPerSec, 0) / results.length);
+		const avgFirstToken = Math.round(results.reduce((a, r) => a + r.firstToken, 0) / results.length);
+		console.log(`\n${chalk.bold("Average")}: ${chalk.cyan(avgTokPerSec)} tok/s · ${chalk.yellow(`${avgFirstToken}ms`)} first token (${results.length} runs on ${chalk.green(g.getDeviceMode().toUpperCase())})\n`);
 		await g.dispose();
-	} catch (_e) {
-		spinner.fail("Error");
+	} catch (e) {
+		spinner.fail(`Error: ${e?.message ?? e}`);
 		process.exit(1);
 	}
 });
 program.command("update").description("Update Gerbil to the latest version").action(async () => {
-	const { checkForUpdate: checkForUpdate$1, installUpdate: installUpdate$1, CURRENT_VERSION: CURRENT_VERSION$1 } = await import("./auto-update-S9s5-g0C.mjs");
+	const { checkForUpdate: checkForUpdate$1, installUpdate: installUpdate$1, CURRENT_VERSION: CURRENT_VERSION$1 } = await import("./auto-update-BVaLXcDE.mjs");
 	const spinner = ora("Checking for updates...").start();
 	try {
 		const check = await checkForUpdate$1();
@@ -9780,8 +9306,9 @@ program.parse = (...args) => {
 	return result;
 };
 async function checkForUpdateCLI() {
-	const { checkForUpdate: checkForUpdate$1, CURRENT_VERSION: CURRENT_VERSION$1 } = await import("./auto-update-S9s5-g0C.mjs");
-	if ((await checkForUpdate$1()).updateAvailable) {}
+	const { checkForUpdate: checkForUpdate$1, CURRENT_VERSION: CURRENT_VERSION$1 } = await import("./auto-update-BVaLXcDE.mjs");
+	const check = await checkForUpdate$1();
+	if (check.updateAvailable) console.error(chalk.yellow(`\nUpdate available: v${CURRENT_VERSION$1} → v${check.latestVersion}. Run ${chalk.cyan("gerbil update")}.`));
 }
 program.parse();