pudu-ai 0.2.18 → 0.2.21

package/dist/cli/index.js

@@ -1,195 +1,92 @@
 #!/usr/bin/env node
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res, err) => function __init() {
-  if (err) throw err[0];
-  try {
-    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-  } catch (e) {
-    throw err = [e], e;
-  }
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/shared/process.ts
-import { execa } from "execa";
-function installSignalHandlers() {
-  if (installed) return;
-  installed = true;
-  const stop = () => {
-    void killAll("SIGTERM");
-  };
-  process.once("SIGINT", stop);
-  process.once("SIGTERM", stop);
-}
-function spawnTracked(file, args2 = [], options = {}) {
-  installSignalHandlers();
-  const subprocess = execa(file, args2, {
-    reject: false,
-    timeout: options.timeout ?? 3e4,
-    ...options
-  });
-  children.add(subprocess);
-  void subprocess.finally(() => {
-    children.delete(subprocess);
-  });
-  return subprocess;
-}
-function toText(value) {
-  if (typeof value === "string") return value;
-  if (value instanceof Uint8Array) return Buffer.from(value).toString("utf8");
-  if (Array.isArray(value)) return value.map(String).join("\n");
-  if (value == null) return "";
-  return String(value);
-}
-async function runCommand(file, args2 = [], options = {}) {
-  const result = await spawnTracked(file, args2, options);
-  return {
-    stdout: toText(result.stdout),
-    stderr: toText(result.stderr),
-    exitCode: result.exitCode,
-    timedOut: Boolean(result.timedOut)
-  };
-}
-async function killAll(signal = "SIGTERM") {
-  for (const child of [...children]) {
-    child.kill(signal);
-  }
-}
-var children, installed;
-var init_process = __esm({
-  "src/shared/process.ts"() {
-    "use strict";
-    children = /* @__PURE__ */ new Set();
-    installed = false;
-  }
-});
-
-// src/shared/which.ts
-import { access } from "node:fs/promises";
-import { constants } from "node:fs";
-import path2 from "node:path";
-async function commandExists(name) {
-  if (name.includes("/") || name.includes("\\")) {
-    try {
-      await access(name, constants.X_OK);
-      return name;
-    } catch {
-      return void 0;
-    }
-  }
-  const pathEnv = process.env.PATH ?? "";
-  const parts = pathEnv.split(path2.delimiter);
-  for (const dir of parts) {
-    const candidate = path2.join(dir, name);
-    try {
-      await access(candidate, constants.X_OK);
-      return candidate;
-    } catch {
-      continue;
-    }
-  }
-  return void 0;
-}
-var init_which = __esm({
-  "src/shared/which.ts"() {
-    "use strict";
-  }
-});
-
-// src/integrations/brew.ts
-var brew_exports = {};
-__export(brew_exports, {
-  brewInstall: () => brewInstall,
-  brewInstallCask: () => brewInstallCask,
-  dockerReady: () => dockerReady,
-  ensureBrew: () => ensureBrew,
-  resolveBrew: () => resolveBrew,
-  startDockerDesktop: () => startDockerDesktop,
-  waitForDocker: () => waitForDocker
-});
-async function resolveBrew() {
-  for (const bin of BREW_CANDIDATES) {
-    const found = await commandExists(bin);
-    if (found) return found;
-  }
-  return void 0;
-}
-async function dockerReady() {
-  const docker = await commandExists("docker");
-  if (!docker) return false;
-  const info = await runCommand("docker", ["info"], { timeout: 8e3 });
-  return info.exitCode === 0;
-}
-async function ensureBrew() {
-  const existing = await resolveBrew();
-  if (existing) return { ok: true, brew: existing, log: existing };
-  const install = await runCommand(
-    "/bin/bash",
-    ["-c", 'NONINTERACTIVE=1 /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"'],
-    { timeout: 15 * 6e4 }
-  );
-  const after = await resolveBrew();
-  if (after) return { ok: true, brew: after, log: after };
-  return {
-    ok: false,
-    log: install.stderr || "Homebrew missing. Install: https://brew.sh"
-  };
-}
-async function brewInstall(args2) {
-  const ensured = await ensureBrew();
-  if (!ensured.ok || !ensured.brew) return { ok: false, log: ensured.log };
-  const result = await runCommand(ensured.brew, args2, { timeout: 15 * 6e4 });
-  return {
-    ok: result.exitCode === 0,
-    log: `${ensured.brew} ${args2.join(" ")}
-${result.stdout || result.stderr}`
-  };
-}
-async function brewInstallCask(name) {
-  const brew = await resolveBrew();
-  if (!brew) {
-    const ensured = await ensureBrew();
-    if (!ensured.ok || !ensured.brew) return { ok: false, log: ensured.log };
-    const result2 = await runCommand(ensured.brew, ["install", "--cask", name], { timeout: 15 * 6e4 });
-    return { ok: result2.exitCode === 0, log: result2.stderr || result2.stdout };
-  }
-  const result = await runCommand(brew, ["install", "--cask", name], { timeout: 15 * 6e4 });
-  if (result.exitCode === 0) return { ok: true, log: result.stdout };
-  const formula = await runCommand(brew, ["install", name], { timeout: 15 * 6e4 });
-  return { ok: formula.exitCode === 0, log: formula.stderr || formula.stdout };
-}
-async function startDockerDesktop() {
-  if (process.platform === "darwin") {
-    await runCommand("open", ["-a", "Docker"], { timeout: 15e3 });
-  }
-}
-async function waitForDocker(ms = 9e4) {
-  const start = Date.now();
-  while (Date.now() - start < ms) {
-    if (await dockerReady()) return true;
-    await new Promise((resolve) => setTimeout(resolve, 2500));
-  }
-  return dockerReady();
-}
-var BREW_CANDIDATES;
-var init_brew = __esm({
-  "src/integrations/brew.ts"() {
-    "use strict";
-    init_which();
-    init_process();
-    BREW_CANDIDATES = ["/opt/homebrew/bin/brew", "/usr/local/bin/brew", "brew"];
-  }
-});
+import {
+  bytesToGiB,
+  canInstallGrade,
+  canirunCachePath,
+  compareText,
+  configPath,
+  decideAll,
+  decideLaunch,
+  detectAgents,
+  detectHardware,
+  doctorText,
+  ensureStorage,
+  executeLaunch,
+  hardwareText,
+  historyCsv,
+  historyText,
+  idsLikelyMatch,
+  launchText,
+  listBenchmarks,
+  localCompatibility,
+  modelsText,
+  parseAnswers,
+  parseIntegration,
+  parseSizeToBytes,
+  planTasks,
+  pullOllamaModel,
+  recommendText,
+  reportMarkdown,
+  resolveOllamaTag,
+  resultText,
+  runBenchmark,
+  runtimesText,
+  tasksText
+} from "./chunk-6C5EPKRI.js";
+import {
+  resolveLocale,
+  setLocale,
+  t
+} from "./chunk-QGEXKMQ5.js";
+import {
+  commandExists,
+  killAll,
+  runCommand
+} from "./chunk-SS7OXXQQ.js";
 
 // src/cli/parse-args.ts
+var VALUE_FLAGS = /* @__PURE__ */ new Set([
+  "--preset",
+  "--lang",
+  "--locale",
+  "--for",
+  "--scope",
+  "--priority",
+  "--link",
+  "--structural",
+  "--repo",
+  "--intent",
+  "--limit",
+  "--glob"
+]);
+function flagValue(args2, name) {
+  const index = args2.findIndex((a) => a === name);
+  if (index < 0) return void 0;
+  const value = args2[index + 1];
+  if (!value || value.startsWith("-")) return void 0;
+  return value;
+}
+function flagValues(args2, name) {
+  const values = [];
+  for (let i = 0; i < args2.length; i++) {
+    if (args2[i] === name) {
+      const value = args2[i + 1];
+      if (value && !value.startsWith("-")) values.push(value);
+    }
+  }
+  return values;
+}
 function parseArgs(argv) {
   const args2 = argv.slice(2);
   const flags = new Set(args2.filter((a) => a.startsWith("-")));
-  const rest = args2.filter((a) => !a.startsWith("-"));
+  const consumed = /* @__PURE__ */ new Set();
+  for (let i = 0; i < args2.length; i++) {
+    const current = args2[i];
+    if (current && VALUE_FLAGS.has(current) && args2[i + 1] && !args2[i + 1].startsWith("-")) {
+      consumed.add(i + 1);
+    }
+  }
+  const rest = args2.filter((a, i) => !a.startsWith("-") && !consumed.has(i));
   const command = rest[0] ?? "dashboard";
   const known = [
     "dashboard",
@@ -203,19 +100,14 @@ function parseArgs(argv) {
     "report",
     "tasks",
     "launch",
-    "setup"
+    "setup",
+    "repo"
   ];
   const isKnown = known.includes(command);
   let addPath;
   if (command === "models" && rest[1] === "add-path") addPath = rest[2];
-  const presetIndex = args2.findIndex((a) => a === "--preset");
-  const preset = presetIndex >= 0 ? args2[presetIndex + 1] : void 0;
-  const langIndex = args2.findIndex((a) => a === "--lang" || a === "--locale");
-  const lang = langIndex >= 0 ? args2[langIndex + 1] : void 0;
-  const forIndex = args2.findIndex((a) => a === "--for");
-  const scopeIndex = args2.findIndex((a) => a === "--scope");
-  const priorityIndex = args2.findIndex((a) => a === "--priority");
-  const linkIndex = args2.findIndex((a) => a === "--link");
+  const limitRaw = flagValue(args2, "--limit");
+  const limit = limitRaw && /^\d+$/.test(limitRaw) ? Number(limitRaw) : void 0;
   return {
     command: isKnown ? command : "dashboard",
     positional: isKnown ? rest.slice(1) : rest,
@@ -224,301 +116,25 @@ function parseArgs(argv) {
     network: !flags.has("--no-network"),
     color: !flags.has("--no-color"),
     verbose: flags.has("--verbose"),
-    preset,
+    preset: flagValue(args2, "--preset"),
     markdown: flags.has("--markdown"),
     help: flags.has("-h") || flags.has("--help"),
     addPath,
-    lang,
-    forKinds: forIndex >= 0 ? args2[forIndex + 1] : void 0,
-    scope: scopeIndex >= 0 ? args2[scopeIndex + 1] : void 0,
-    priority: priorityIndex >= 0 ? args2[priorityIndex + 1] : void 0,
+    lang: flagValue(args2, "--lang") ?? flagValue(args2, "--locale"),
+    forKinds: flagValue(args2, "--for"),
+    scope: flagValue(args2, "--scope"),
+    priority: flagValue(args2, "--priority"),
     yes: flags.has("--yes"),
     install: flags.has("--install"),
-    link: linkIndex >= 0 ? args2[linkIndex + 1] : void 0
-  };
-}
-
-// src/storage/config.ts
-import { readFile, writeFile } from "node:fs/promises";
-import { z } from "zod";
-
-// src/storage/paths.ts
-import os from "node:os";
-import path from "node:path";
-import { mkdir } from "node:fs/promises";
-function homeDir() {
-  return path.join(os.homedir(), ".pudu-ai");
-}
-function configPath() {
-  return path.join(homeDir(), "config.json");
-}
-function benchmarksDir() {
-  return path.join(homeDir(), "benchmarks");
-}
-function telemetryDir() {
-  return path.join(homeDir(), "telemetry");
-}
-function cacheDir() {
-  return path.join(homeDir(), "cache");
-}
-function canirunCachePath() {
-  return path.join(cacheDir(), "canirun-models.json");
-}
-async function ensureStorage() {
-  await mkdir(benchmarksDir(), { recursive: true });
-  await mkdir(telemetryDir(), { recursive: true });
-  await mkdir(cacheDir(), { recursive: true });
-}
-
-// src/storage/config.ts
-var configSchema = z.object({
-  schemaVersion: z.literal(1),
-  modelPaths: z.array(z.string()).default([]),
-  network: z.boolean().default(true)
-});
-var fallback = { schemaVersion: 1, modelPaths: [], network: true };
-async function loadConfig() {
-  await ensureStorage();
-  try {
-    const raw = await readFile(configPath(), "utf8");
-    return configSchema.parse(JSON.parse(raw));
-  } catch {
-    await saveConfig(fallback);
-    return fallback;
-  }
-}
-async function saveConfig(config) {
-  await ensureStorage();
-  await writeFile(configPath(), `${JSON.stringify(config, null, 2)}
-`, "utf8");
-}
-async function addModelPath(dir) {
-  const config = await loadConfig();
-  if (!config.modelPaths.includes(dir)) config.modelPaths.push(dir);
-  await saveConfig(config);
-  return config;
-}
-
-// src/hardware/detect.ts
-import os5 from "node:os";
-
-// src/platform/macos/hardware.ts
-init_process();
-import os2 from "node:os";
-
-// src/shared/bytes.ts
-var GiB = 1024 ** 3;
-var MiB = 1024 ** 2;
-function bytesToGiB(bytes) {
-  return bytes / GiB;
-}
-function parseSizeToBytes(input) {
-  const match = input.trim().match(/^([\d.]+)\s*(B|KB|MB|GB|TB|KiB|MiB|GiB|TiB)$/i);
-  if (!match) return void 0;
-  const value = Number(match[1]);
-  const unit = match[2].toLowerCase();
-  const map = {
-    b: 1,
-    kb: 1e3,
-    mb: 1e3 ** 2,
-    gb: 1e3 ** 3,
-    tb: 1e3 ** 4,
-    kib: 1024,
-    mib: 1024 ** 2,
-    gib: 1024 ** 3,
-    tib: 1024 ** 4
-  };
-  const factor = map[unit];
-  if (!factor || Number.isNaN(value)) return void 0;
-  return value * factor;
-}
-function formatBytes(bytes, digits = 1) {
-  if (!Number.isFinite(bytes)) return "N/A";
-  const abs = Math.abs(bytes);
-  if (abs >= GiB) return `${(bytes / GiB).toFixed(digits)} GB`;
-  if (abs >= MiB) return `${(bytes / MiB).toFixed(digits)} MB`;
-  if (abs >= 1024) return `${(bytes / 1024).toFixed(digits)} KB`;
-  return `${Math.round(bytes)} B`;
-}
-
-// src/platform/macos/hardware.ts
-function parseAppleSilicon(chip) {
-  const match = chip.match(/Apple\s+(M\d+)(?:\s+(Pro|Max|Ultra))?/i);
-  if (!match) return void 0;
-  const generation = match[1].toUpperCase().replace(/^M/, "M");
-  const variant = match[2] ?? "base";
-  return { generation, variant };
-}
-function parseVmStat(output, pageSize) {
-  const num = (label) => {
-    const row = output.match(new RegExp(`${label}:\\s+([\\d.]+)`));
-    if (!row) return void 0;
-    return Number(row[1]);
-  };
-  const free = num("Pages free") ?? 0;
-  const speculative = num("Pages speculative") ?? 0;
-  const inactive = num("Pages inactive") ?? 0;
-  const purgeable = num("Pages purgeable") ?? 0;
-  const availableBytes = (free + speculative + inactive + purgeable) * pageSize;
-  return { availableBytes };
-}
-function parseMemoryPressure(output) {
-  const match = output.match(/System-wide memory free percentage:\s+(\d+)/i);
-  if (match) {
-    const free = Number(match[1]);
-    if (free >= 50) return "Nominal";
-    if (free >= 25) return "Warn";
-    return "Critical";
-  }
-  if (/warn/i.test(output)) return "Warn";
-  if (/critical/i.test(output)) return "Critical";
-  if (/nominal/i.test(output)) return "Nominal";
-  return void 0;
-}
-function parseMacosSwapUsage(output) {
-  const match = output.match(/used\s*=\s*([\d.]+)\s*([KMGT])?/i);
-  if (!match) return void 0;
-  const value = Number(match[1]);
-  if (Number.isNaN(value)) return void 0;
-  const unit = (match[2] ?? "M").toUpperCase();
-  const factor = { K: 1024, M: 1024 ** 2, G: 1024 ** 3, T: 1024 ** 4 }[unit] ?? 1024 ** 2;
-  return value * factor;
-}
-async function detectMacosHardware() {
-  const [brand, physical, logical, memsize, pagesize, perf, eff, hwModel, swVers, profiler, vmstat, pressure, swap] = await Promise.all([
-    runCommand("sysctl", ["-n", "machdep.cpu.brand_string"], { timeout: 5e3 }),
-    runCommand("sysctl", ["-n", "hw.physicalcpu"], { timeout: 5e3 }),
-    runCommand("sysctl", ["-n", "hw.logicalcpu"], { timeout: 5e3 }),
-    runCommand("sysctl", ["-n", "hw.memsize"], { timeout: 5e3 }),
-    runCommand("sysctl", ["-n", "hw.pagesize"], { timeout: 5e3 }),
-    runCommand("sysctl", ["-n", "hw.perflevel0.physicalcpu"], { timeout: 5e3 }),
-    runCommand("sysctl", ["-n", "hw.perflevel1.physicalcpu"], { timeout: 5e3 }),
-    runCommand("sysctl", ["-n", "hw.model"], { timeout: 5e3 }),
-    runCommand("sw_vers", ["-productVersion"], { timeout: 5e3 }),
-    runCommand("system_profiler", ["SPHardwareDataType"], { timeout: 15e3 }),
-    runCommand("vm_stat", [], { timeout: 5e3 }),
-    runCommand("memory_pressure", [], { timeout: 5e3 }),
-    runCommand("sysctl", ["-n", "vm.swapusage"], { timeout: 5e3 })
-  ]);
-  const profilerText = profiler.stdout;
-  const chip = profilerText.match(/Chip:\s+(.+)/)?.[1]?.trim() ?? brand.stdout.trim() ?? os2.cpus()[0]?.model;
-  const modelName = profilerText.match(/Model Name:\s+(.+)/)?.[1]?.trim();
-  const memoryLine = profilerText.match(/Memory:\s+(.+)/)?.[1]?.trim();
-  const totalFromProfiler = memoryLine ? parseSizeToBytes(memoryLine.replace("GB", "GiB")) : void 0;
-  const totalBytes = totalFromProfiler ?? Number(memsize.stdout.trim()) ?? os2.totalmem();
-  const pageSize = Number(pagesize.stdout.trim()) || 16384;
-  const vm = parseVmStat(vmstat.stdout, pageSize);
-  const appleSilicon = chip ? parseAppleSilicon(chip) : void 0;
-  return {
-    os: "macos",
-    osVersion: swVers.stdout.trim() || void 0,
-    arch: os2.arch(),
-    machineModel: modelName ?? hwModel.stdout.trim() ?? void 0,
-    cpu: {
-      name: chip,
-      physicalCores: Number(physical.stdout.trim()) || os2.cpus().length,
-      logicalCores: Number(logical.stdout.trim()) || os2.cpus().length,
-      performanceCores: Number(perf.stdout.trim()) || void 0,
-      efficiencyCores: Number(eff.stdout.trim()) || void 0,
-      appleSilicon
-    },
-    gpu: {
-      name: chip,
-      metal: Boolean(appleSilicon) || os2.arch() === "arm64"
-    },
-    memory: {
-      totalBytes,
-      availableBytes: vm.availableBytes ?? os2.freemem(),
-      unified: Boolean(appleSilicon) || os2.arch() === "arm64",
-      swapUsedBytes: parseMacosSwapUsage(swap.stdout),
-      pressure: parseMemoryPressure(pressure.stdout + pressure.stderr)
-    }
-  };
-}
-function parseMacosMemoryPressure(output) {
-  return parseMemoryPressure(output);
-}
-function parseMacosVmStat(output, pageSize) {
-  return parseVmStat(output, pageSize);
-}
-
-// src/platform/linux/hardware.ts
-import os3 from "node:os";
-async function detectLinuxHardware() {
-  return {
-    os: "linux",
-    arch: os3.arch(),
-    cpu: {
-      name: os3.cpus()[0]?.model,
-      logicalCores: os3.cpus().length
-    },
-    gpu: {},
-    memory: {
-      totalBytes: os3.totalmem(),
-      availableBytes: os3.freemem(),
-      unified: false
-    }
-  };
-}
-
-// src/platform/windows/hardware.ts
-import os4 from "node:os";
-async function detectWindowsHardware() {
-  return {
-    os: "windows",
-    arch: os4.arch(),
-    cpu: {
-      name: os4.cpus()[0]?.model,
-      logicalCores: os4.cpus().length
-    },
-    gpu: {},
-    memory: {
-      totalBytes: os4.totalmem(),
-      availableBytes: os4.freemem(),
-      unified: false
-    }
-  };
-}
-
-// src/hardware/detect.ts
-function detectOs() {
-  switch (process.platform) {
-    case "darwin":
-      return "macos";
-    case "linux":
-      return "linux";
-    case "win32":
-      return "windows";
-    default:
-      return "unknown";
-  }
-}
-async function detectHardware() {
-  const osName = detectOs();
-  if (osName === "macos") return detectMacosHardware();
-  if (osName === "linux") return detectLinuxHardware();
-  if (osName === "windows") return detectWindowsHardware();
-  return {
-    os: "unknown",
-    arch: os5.arch(),
-    cpu: { name: os5.cpus()[0]?.model, logicalCores: os5.cpus().length },
-    gpu: {},
-    memory: {
-      totalBytes: os5.totalmem(),
-      availableBytes: os5.freemem(),
-      unified: false
-    }
+    link: flagValue(args2, "--link"),
+    structural: flagValue(args2, "--structural"),
+    repo: flagValue(args2, "--repo"),
+    intent: flagValue(args2, "--intent"),
+    limit,
+    globs: flagValues(args2, "--glob")
   };
 }
 
-// src/models/discovery.ts
-import os7 from "node:os";
-import path5 from "node:path";
-
-// src/adapters/ollama/index.ts
-init_process();
-init_which();
-
 // src/adapters/ollama/parse.ts
 function parseOllamaList(output) {
   const lines = output.split(/\r?\n/).map((l) => l.trimEnd()).filter(Boolean);
@@ -569,14 +185,7 @@ var ollamaAdapter = {
   async listModels() {
     if (!await this.detect()) return [];
     const result = await runCommand("ollama", ["list"], { timeout: 15e3 });
-    const models = parseOllamaList(result.stdout);
-    const resolved = await Promise.all(
-      models.map(async (model) => {
-        const artifact = await resolveOllamaBlob(model.id);
-        return { ...model, artifactPath: artifact?.path };
-      })
-    );
-    return resolved;
+    return parseOllamaList(result.stdout);
   },
   async resolveModel(id) {
     return resolveOllamaBlob(id);
@@ -594,15 +203,49 @@ async function resolveOllamaBlob(id) {
   return { id, path: from, format };
 }
 
+// src/storage/config.ts
+import { readFile, writeFile } from "node:fs/promises";
+import { z } from "zod";
+var configSchema = z.object({
+  schemaVersion: z.literal(1),
+  modelPaths: z.array(z.string()).default([]),
+  network: z.boolean().default(true)
+});
+var fallback = { schemaVersion: 1, modelPaths: [], network: true };
+async function loadConfig() {
+  await ensureStorage();
+  try {
+    const raw = await readFile(configPath(), "utf8");
+    return configSchema.parse(JSON.parse(raw));
+  } catch {
+    await saveConfig(fallback);
+    return fallback;
+  }
+}
+async function saveConfig(config) {
+  await ensureStorage();
+  await writeFile(configPath(), `${JSON.stringify(config, null, 2)}
+`, "utf8");
+}
+async function addModelPath(dir) {
+  const config = await loadConfig();
+  if (!config.modelPaths.includes(dir)) config.modelPaths.push(dir);
+  await saveConfig(config);
+  return config;
+}
+
+// src/models/discovery.ts
+import os2 from "node:os";
+import path3 from "node:path";
+
 // src/adapters/lmstudio/index.ts
-import os6 from "node:os";
-import path4 from "node:path";
-import { access as access2 } from "node:fs/promises";
+import os from "node:os";
+import path2 from "node:path";
+import { access } from "node:fs/promises";
 
 // src/adapters/llamacpp/index.ts
-init_which();
 import { readdir, stat } from "node:fs/promises";
-import path3 from "node:path";
+import path from "node:path";
 var BINARIES = ["llama-bench", "llama-cli", "llama-server"];
 async function detectLlamaCpp() {
   const entries = await Promise.all(BINARIES.map(async (bin) => [bin, Boolean(await commandExists(bin))]));
@@ -625,7 +268,7 @@ async function walk(dir, depth, maxDepth, source, models) {
     return;
   }
   for (const entry of entries) {
-    const full = path3.join(dir, entry);
+    const full = path.join(dir, entry);
     try {
       const info = await stat(full);
       if (info.isFile() && entry.toLowerCase().endsWith(".gguf")) {
@@ -669,18 +312,18 @@ var llamaCppAdapter = {
 
 // src/adapters/lmstudio/index.ts
 function lmStudioCandidateDirs() {
-  const home = os6.homedir();
+  const home = os.homedir();
   return [
-    path4.join(home, ".lmstudio", "models"),
-    path4.join(home, ".cache", "lm-studio", "models"),
-    path4.join(home, "Library", "Application Support", "LM Studio", "models")
+    path2.join(home, ".lmstudio", "models"),
+    path2.join(home, ".cache", "lm-studio", "models"),
+    path2.join(home, "Library", "Application Support", "LM Studio", "models")
   ];
 }
 async function existingDirs() {
   const found = [];
   for (const dir of lmStudioCandidateDirs()) {
     try {
-      await access2(dir);
+      await access(dir);
       found.push(dir);
     } catch {
       continue;
@@ -714,12 +357,12 @@ var lmStudioAdapter = {
 
 // src/models/discovery.ts
 function defaultGgufDirs() {
-  const home = os7.homedir();
+  const home = os2.homedir();
   return [
-    path5.join(home, "Models"),
-    path5.join(home, "models"),
-    path5.join(home, ".cache", "llama.cpp"),
-    path5.join(home, ".local", "share", "llama.cpp")
+    path3.join(home, "Models"),
+    path3.join(home, "models"),
+    path3.join(home, ".cache", "llama.cpp"),
+    path3.join(home, ".local", "share", "llama.cpp")
   ];
 }
 async function discoverLocalModels() {
@@ -739,7 +382,6 @@ async function discoverLocalModels() {
 }
 
 // src/adapters/mlx/index.ts
-init_which();
 var mlxAdapter = {
   id: "mlx",
   label: "MLX",
@@ -761,7 +403,6 @@ var mlxAdapter = {
 };
 
 // src/runtimes/registry.ts
-init_which();
 var runtimes = [ollamaAdapter, llamaCppAdapter, lmStudioAdapter, mlxAdapter];
 async function detectRuntimes() {
   const llamaBench = Boolean(await commandExists("llama-bench"));
@@ -846,31 +487,31 @@ function hardwarePayload(hardware) {
     gpu: hardware.gpu.name ? { name: hardware.gpu.name } : void 0
   };
 }
-async function postJson(path7, body, timeoutMs) {
+async function postJson(path4, body, timeoutMs) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), timeoutMs);
   try {
-    const response = await fetch(`${BASE}${path7}`, {
+    const response = await fetch(`${BASE}${path4}`, {
       method: "POST",
       headers: { "content-type": "application/json", accept: "application/json" },
       body: JSON.stringify(body),
       signal: controller.signal
     });
-    if (!response.ok) throw new Error(`CanIRun ${path7} ${response.status}`);
+    if (!response.ok) throw new Error(`CanIRun ${path4} ${response.status}`);
     return await response.json();
   } finally {
     clearTimeout(timer);
   }
 }
-async function getJson(path7, timeoutMs) {
+async function getJson(path4, timeoutMs) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), timeoutMs);
   try {
-    const response = await fetch(`${BASE}${path7}`, {
+    const response = await fetch(`${BASE}${path4}`, {
       headers: { accept: "application/json" },
       signal: controller.signal
     });
-    if (!response.ok) throw new Error(`CanIRun ${path7} ${response.status}`);
+    if (!response.ok) throw new Error(`CanIRun ${path4} ${response.status}`);
     return await response.json();
   } finally {
     clearTimeout(timer);
@@ -919,16 +560,6 @@ async function fetchRecommendations(hardware, useCase, limit = 5) {
   }));
 }
 
-// src/models/match.ts
-function normalizeModelId(id) {
-  return id.toLowerCase().replace(/[:/]/g, "-").replace(/[^a-z0-9.-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
-}
-function idsLikelyMatch(a, b) {
-  const na2 = normalizeModelId(a);
-  const nb = normalizeModelId(b);
-  return na2 === nb || na2.includes(nb) || nb.includes(na2);
-}
-
 // src/storage/cache.ts
 import { readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
 async function saveCatalogCache(models) {
@@ -947,489 +578,6 @@ async function loadCatalogCache() {
   }
 }
 
-// src/i18n/en.ts
-var en = {
-  appTitle: "PUDU-AI",
-  appSubtitle: "Local AI Hardware & Benchmark Lab",
-  byline: "by devjaime",
-  aboutDashboard: "Opens the live lab: your machine, installed models, and estimates. Use it to see what can run here before you benchmark or launch a tool.",
-  aboutHardware: "Detects CPU, GPU, and Unified Memory/RAM. Use it to know what this computer can host before pulling a model.",
-  aboutModels: "Lists installed models vs catalog fits. FIT/EST. SPEED are estimated (CanIRun.ai by midudev); MEASURED is llama-bench history. Use it to separate \u201Calready here\u201D from \u201Cmight run\u201D.",
-  aboutRecommend: "Suggests models by use case for this hardware. Estimates only, unless you already measured. Use it to pick a size class, not a quality score.",
-  aboutTasks: "Asks what you want (code, video, image, transcription, chat) and returns small OpenCode-style harnesses per model, in this language. Use it to try a model on one concrete job.",
-  aboutBenchmark: "Runs llama-bench on a local GGUF and records measured t/s plus system telemetry. Use it when you need real numbers, not estimates.",
-  aboutCompare: "Compares saved measured runs (speed, memory, power). Quality is never inferred from speed. Use it after two or more benchmarks.",
-  compareHow: "[C] Compare needs two measured llama-bench runs of different models. Press [B], pick a model, wait; repeat with another; then [C]. Quality is not a speed score.",
-  compareNeedBench: "Need 2+ measured models. Press [B] to benchmark first.",
-  reqOllama: "install: https://ollama.com/download  or  brew install ollama",
-  reqLmStudio: "install: https://lmstudio.ai",
-  reqDocker: "install: https://docs.docker.com/get-docker/  or  brew install --cask docker",
-  dockerHint: "press 4 to run ollama/ollama in Docker",
-  dockerStarting: "Starting ollama/ollama container\u2026",
-  dockerRunOk: "Docker Ollama is up on port 11434 (name: pudu-ollama).",
-  dockerRunFail: "Docker daemon is not running. Open Docker Desktop, wait until it is idle, press 4 again.",
-  dockerBrewInstall: "Installing Docker with Homebrew (brew install --cask docker)\u2026",
-  dockerDesktopWait: "Starting Docker Desktop and waiting for the daemon\u2026",
-  brewInstalling: "Homebrew: installing {pkg}\u2026",
-  aboutHistory: "Shows local benchmark files in ~/.pudu-ai/benchmarks. Use it to replay what this machine actually did.",
-  aboutDoctor: "Checks Node, Apple Silicon/Metal, Ollama, llama-bench, and the CanIRun API. Use it to see what is missing before a bench or launch.",
-  aboutReport: "Writes the latest measured run as Markdown. Use it to paste results into GitHub or notes.",
-  aboutLaunch: "Explains Ollama integrations (OpenCode, OpenClaw, Hermes, Claude Code). Pull/launch only with --yes if the model grade is S\u2013B and speed is enough. Use it to wire a coding agent only when this hardware can carry it.",
-  aboutAddPath: "Adds a GGUF folder to scan (not the whole disk). Use it so llama-bench can find models outside Ollama.",
-  nav: "[S] Setup/Install  [B] Benchmark  [M] Models  [R] Recommend  [T] Tasks  [H] Hardware  [C] Compare  [L] History  [Q] Quit",
-  setupTitle: "SETUP \u2014 INSTALL MODELS & AGENTS",
-  setupIntro: "Pick a recommended model (grade S\u2013B), install it with Ollama, then link or install OpenCode, Hermes, or OpenClaw.",
-  setupStep1: "1. Recommended models (\u2191\u2193 to choose)",
-  setupStep2: "2. Install the selected model",
-  setupInstallModel: "Press Enter or I  \u2192  ollama pull (only if grade is S, A, or B)",
-  setupStep3: "3. Coding agent \u2014 link if present, install if missing",
-  setupLinkNow: "installed \u2192 press 1/2/3 to link this model",
-  setupInstallAgent: "not installed \u2192 press 1/2/3 to install via ollama launch (if eligible)",
-  setupKeys: "Enter/I = pull model    1 OpenCode    2 Hermes    3 OpenClaw    Esc = back",
-  setupCta: "[S] Setup: install model + OpenCode / Hermes / OpenClaw",
-  machine: "MACHINE",
-  runtimes: "LOCAL AI RUNTIMES",
-  installedModels: "INSTALLED MODELS",
-  compatible: "COMPATIBLE (catalog, estimated)",
-  recommended: "RECOMMENDED FOR THIS MACHINE",
-  recommendedHint: "Estimated values come from CanIRun.ai by midudev (canirun.ai \xB7 midu.dev) or a local fallback \u2014 not measured",
-  recommendKeys: "[\u2191\u2193] model  [I] ollama pull if grade S\u2013B  [O] OpenCode  [E] Hermes  [W] OpenClaw  [Esc] back",
-  recommendCliHint: "Install: npx pudu-ai recommend --install --yes   Link: npx pudu-ai recommend --link opencode --yes",
-  agentsTitle: "CODING AGENTS",
-  agentMissing: "not installed \u2014 select to install via ollama launch if the model is eligible",
-  installGradeBlock: "Grade {grade} is too low to pull. Need S, A, or B.",
-  linkingTool: "Linking {tool} with {model}\u2026",
-  modelPulled: "Pulled {model} with Ollama.",
-  installNone: "No recommended model has grade S\u2013B to install.",
-  noOllamaTag: "No Ollama library tag for {model}. Catalog names like Agents-A1 are not pullable. Use qwen3:8b, gemma3:4b, qwen3.5:4b, llama3.1:8b.",
-  credits: "Measured: llama-bench + OS telemetry. Estimated: CanIRun.ai by midudev (https://canirun.ai, https://github.com/midudev/canirun.ai, https://midu.dev). Labelled separately; never mixed.",
-  noModels: "No local models detected",
-  notTested: "Not tested",
-  detected: "detected",
-  notDetected: "not detected",
-  unknownMachine: "Unknown machine",
-  cpuNa: "CPU N/A",
-  selectBenchmark: "Select model to benchmark",
-  enterToRun: "Enter to run llama-bench  \xB7  Esc back",
-  noGguf: "No GGUF-resolvable models to benchmark.",
-  performance: "PERFORMANCE",
-  system: "SYSTEM",
-  powerThermals: "POWER / THERMALS",
-  elapsed: "Elapsed",
-  measuredAfter: "Prompt / generation t/s appear after llama-bench finishes (measured).",
-  permissionsHint: "GPU % and power need extra permissions; shown as N/A when not measured.",
-  cancelHint: "Ctrl+C / Q cancels llama-bench and telemetry",
-  saved: "Saved",
-  hardwareHint: "Power, GPU %, and thermals require extra OS permissions and show N/A when unavailable.",
-  modelsHint: "FIT and EST. SPEED are estimated. MEASURED comes from local llama-bench history.",
-  historyEmpty: "No benchmark history in ~/.pudu-ai/benchmarks",
-  compareNeedTwo: "Need at least two measured benchmarks to compare.",
-  compareTitle: "LOCAL MODEL BENCHMARKS (measured)",
-  winner: "Winner",
-  qualityNote: "Quality     (not derived from speed; see catalog metadata)",
-  doctorTitle: "Pudu-AI Doctor",
-  doctorReady: "Ready to benchmark {count} installed models.",
-  doctorNoBench: "llama-bench unavailable. Install llama.cpp, e.g. `brew install llama.cpp`. Pudu-AI will not install native dependencies.",
-  loading: "Inspecting hardware, runtimes, and local models\u2026",
-  addedPath: "Added model path {path}",
-  modelNotFound: "Model not found: {id}",
-  noHistory: "No benchmark history.",
-  jsonNeedModel: "Pass a model id for JSON mode, e.g. npx pudu-ai benchmark qwen3:8b --json",
-  useCaseCoding: "Coding",
-  useCaseGeneral: "General",
-  useCaseReasoning: "Reasoning",
-  useCaseLightweight: "Lightweight",
-  estimated: "Estimated",
-  measured: "Measured",
-  scoreLabel: "Pudu-AI Score",
-  reportTitle: "Pudu-AI Benchmark",
-  benchmarkTitle: "Pudu-AI Benchmark",
-  tasksTitle: "TASK HARNESSES",
-  tasksHint: "Small OpenCode-style tasks in your selected language. Installed models first. Catalog matches are Estimated (CanIRun.ai by midudev).",
-  tasksKinds: "Work types",
-  tasksScope: "Scope",
-  tasksPriority: "Priority",
-  tasksInstalled: "installed",
-  tasksNotInstalled: "not installed",
-  tasksEmpty: "No matching models for those work types on this machine.",
-  tasksQ1: "What do you want to do? (space to toggle, enter next)",
-  tasksQ2: "Use only installed models, or also catalog estimates?",
-  tasksQ3: "Priority?",
-  tasksOptCode: "Code",
-  tasksOptVideo: "Video",
-  tasksOptImage: "Image",
-  tasksOptTranscription: "Transcription",
-  tasksOptChat: "Tasks / chat",
-  tasksOptInstalled: "Installed only",
-  tasksOptAll: "Installed + catalog (estimated)",
-  tasksOptSpeed: "Speed",
-  tasksOptBalanced: "Balanced",
-  tasksOptQuality: "Quality",
-  taskCodeReviewTitle: "Review a local diff",
-  taskCodeReviewPrompt: "In OpenCode: open a git diff and ask this model to list bugs, missing tests, and a 5-line summary. Do not apply patches unless you ask.",
-  taskCodeTestsTitle: "Write one failing test",
-  taskCodeTestsPrompt: "Pick one function. Ask the model for a single Vitest/Jest test that fails on the current bug. Do not generate extra files.",
-  taskChatPlanTitle: "Turn a goal into a task list",
-  taskChatPlanPrompt: "Give the model one goal. Require a numbered plan of 5 harness-sized tasks. No implementation yet.",
-  taskChatAgentTitle: "Agent loop on one file",
-  taskChatAgentPrompt: "Point the model at one file and one acceptance check. It may edit only that file, then stop.",
-  taskImageCaptionTitle: "Caption a local image",
-  taskImageCaptionPrompt: "If this is a vision/image model, caption one local image in your UI language. If it is text-only, skip and say N/A.",
-  taskImageBriefTitle: "Image generation brief",
-  taskImageBriefPrompt: "Ask for a 6-line prompt brief (subject, lens, light, negative prompt) for one still. Do not invent that the model rendered the image unless it did.",
-  taskVideoBoardTitle: "8-shot storyboard",
-  taskVideoBoardPrompt: "Ask for 8 shots: duration, camera, action, on-screen text. Keep it local. Do not claim a render exists.",
-  taskVideoShotTitle: "Shot list from a script",
-  taskVideoShotPrompt: "Paste a short script. Ask for a shot list and estimated seconds. Text-only models may plan; they cannot encode video.",
-  taskTranscribeCleanTitle: "Clean a transcript",
-  taskTranscribeCleanPrompt: "Paste noisy speech-to-text. Ask the model to punctuate, remove fillers, and keep speaker labels. This is not ASR; it edits text.",
-  taskTranscribeActionsTitle: "Actions from a transcript",
-  taskTranscribeActionsPrompt: "From a meeting transcript, extract owners, due dates, and open questions as a checklist in your UI language.",
-  launchTitle: "OLLAMA INTEGRATIONS",
-  launchHint: "Explain-only by default. Pull/install/launch run only with --yes and only if a recommended model fits this hardware (grade S\u2013B; measured speed when available). Docs: OpenCode, OpenClaw, Hermes, Claude Code via Ollama.",
-  launchNeedOllama: "Ollama is not detected. Install Ollama first. Pudu-AI will not install it.",
-  launchNoModel: "No coding/chat model on this machine meets the hardware bar for this integration.",
-  launchGradeFail: "Grade {grade} is below the allowed set ({allowed}).",
-  launchSlowFail: "Measured {tps} t/s is below the {min} t/s agent floor.",
-  launchEstimateWeak: "Only a weak estimate is available; will not pull or launch.",
-  launchOk: "Eligible on this hardware for recommended tasks.",
-  launchModel: "Model",
-  launchRunHint: "To pull (if needed) and launch: npx pudu-ai launch {tool} --yes",
-  launchBlocked: "Blocked. No pull, install, or launch.",
-  launchNeedTool: "Pass a tool: opencode | openclaw | hermes | claude",
-  launchUnknown: "Unknown integration.",
-  launchPulling: "Pulling {model} with ollama pull\u2026",
-  launchPullFail: "ollama pull failed.",
-  launchExecFail: "ollama launch failed.",
-  help: `Pudu-AI \u2014 local AI hardware & benchmark lab
-
-Usage:
-  npx pudu-ai
-  npx pudu-ai hardware
-  npx pudu-ai models
-  npx pudu-ai models add-path ~/Models
-  npx pudu-ai setup
-  npx pudu-ai recommend
-  npx pudu-ai recommend --install --yes
-  npx pudu-ai recommend --link opencode --yes
-  npx pudu-ai tasks
-  npx pudu-ai tasks --for code,image --scope all --priority speed
-  npx pudu-ai benchmark [model]
-  npx pudu-ai compare
-  npx pudu-ai history
-  npx pudu-ai doctor
-  npx pudu-ai report --markdown
-  npx pudu-ai launch
-  npx pudu-ai launch opencode
-  npx pudu-ai launch opencode --yes
-
-Flags:
-  --json          Machine-readable JSON (no TUI)
-  --csv           CSV output
-  --no-network    Skip CanIRun API; use cache/local estimates
-  --no-color      Disable ANSI color
-  --verbose       Debug logs to stderr
-  --preset        quick | standard | stress
-  --lang          en | es
-  --for           code,video,image,transcription,chat
-  --scope         installed | all
-  --priority      speed | balanced | quality
-  --yes           Execute pull/launch only if the model is eligible
-
-Credits:
-  Measured values come from llama-bench and OS telemetry.
-  Estimated values come from CanIRun.ai by midudev
-  (https://canirun.ai \xB7 https://github.com/midudev/canirun.ai \xB7 https://midu.dev)
-  or a local fallback, and are labelled as such.
-`
-};
-
-// src/i18n/es.ts
-var es = {
-  appTitle: "PUDU-AI",
-  appSubtitle: "Laboratorio local de hardware y benchmarks de IA",
-  byline: "by devjaime",
-  aboutDashboard: "Abre el laboratorio en vivo: equipo, modelos instalados y estimaciones. Sirve para ver qu\xE9 puede correr aqu\xED antes de medir o lanzar una herramienta.",
-  aboutHardware: "Detecta CPU, GPU y memoria unificada/RAM. Sirve para saber qu\xE9 puede hospedar este equipo antes de descargar un modelo.",
-  aboutModels: "Lista instalados frente al cat\xE1logo. FIT/EST. SPEED son estimados (CanIRun.ai de midudev); MEASURED es historial de llama-bench. Sirve para separar \u201Cya est\xE1\u201D de \u201Cpodr\xEDa correr\u201D.",
-  aboutRecommend: "Sugiere modelos por caso de uso para este hardware. Solo estimaciones, salvo que ya hayas medido. Sirve para elegir un tama\xF1o, no una nota de calidad.",
-  aboutTasks: "Pregunta qu\xE9 quieres (c\xF3digo, v\xEDdeo, imagen, transcripci\xF3n, chat) y devuelve harnesses peque\xF1os estilo OpenCode por modelo, en este idioma. Sirve para probar un modelo en una tarea concreta.",
-  aboutBenchmark: "Ejecuta llama-bench sobre un GGUF local y guarda t/s medidos m\xE1s telemetr\xEDa. Sirve cuando necesitas n\xFAmeros reales, no estimaciones.",
-  aboutCompare: "Compara corridas medidas (velocidad, memoria, potencia). La calidad no se infiere de la velocidad. Sirve despu\xE9s de dos o m\xE1s benchmarks.",
-  compareHow: "[C] Comparar necesita dos corridas medidas de llama-bench en modelos distintos. Pulsa [B], elige un modelo, espera; repite con otro; luego [C]. La calidad no es un score de velocidad.",
-  compareNeedBench: "Hacen falta 2+ modelos medidos. Pulsa [B] para hacer un benchmark primero.",
-  reqOllama: "instalar: https://ollama.com/download  o  brew install ollama",
-  reqLmStudio: "instalar: https://lmstudio.ai",
-  reqDocker: "instalar: https://docs.docker.com/get-docker/  o  brew install --cask docker",
-  dockerHint: "pulsa 4 para correr ollama/ollama en Docker",
-  dockerStarting: "Arrancando contenedor ollama/ollama\u2026",
-  dockerRunOk: "Ollama en Docker est\xE1 en el puerto 11434 (nombre: pudu-ollama).",
-  dockerRunFail: "El daemon de Docker no corre. Abre Docker Desktop, espera a que est\xE9 listo y pulsa 4 otra vez.",
-  dockerBrewInstall: "Instalando Docker con Homebrew (brew install --cask docker)\u2026",
-  dockerDesktopWait: "Arrancando Docker Desktop y esperando al daemon\u2026",
-  brewInstalling: "Homebrew: instalando {pkg}\u2026",
-  aboutHistory: "Muestra los JSON locales en ~/.pudu-ai/benchmarks. Sirve para ver qu\xE9 hizo realmente esta m\xE1quina.",
-  aboutDoctor: "Revisa Node, Apple Silicon/Metal, Ollama, llama-bench y la API de CanIRun. Sirve para ver qu\xE9 falta antes de un bench o un launch.",
-  aboutReport: "Exporta la \xFAltima corrida medida en Markdown. Sirve para pegar resultados en GitHub o notas.",
-  aboutLaunch: "Explica las integraciones de Ollama (OpenCode, OpenClaw, Hermes, Claude Code). Pull/launch solo con --yes si la nota es S\u2013B y hay velocidad suficiente. Sirve para conectar un agente de c\xF3digo solo cuando el hardware lo aguanta.",
-  aboutAddPath: "A\xF1ade una carpeta GGUF a escanear (no todo el disco). Sirve para que llama-bench encuentre modelos fuera de Ollama.",
-  nav: "[S] Setup/Instalar  [B] Benchmark  [M] Modelos  [R] Recomendaciones  [T] Tareas  [H] Hardware  [C] Comparar  [L] Historial  [Q] Salir",
-  setupTitle: "SETUP \u2014 INSTALAR MODELOS Y AGENTES",
-  setupIntro: "Elige un modelo recomendado (nota S\u2013B), inst\xE1lalo con Ollama y luego vincula o instala OpenCode, Hermes u OpenClaw.",
-  setupStep1: "1. Modelos recomendados (\u2191\u2193 para elegir)",
-  setupStep2: "2. Instalar el modelo seleccionado",
-  setupInstallModel: "Enter o I  \u2192  ollama pull (solo si la nota es S, A o B)",
-  setupStep3: "3. Agente de c\xF3digo \u2014 vincular si existe, instalar si falta",
-  setupLinkNow: "instalado \u2192 pulsa 1/2/3 para vincular este modelo",
-  setupInstallAgent: "no instalado \u2192 pulsa 1/2/3 para instalar con ollama launch (si es elegible)",
-  setupKeys: "Enter/I = descargar modelo    1 OpenCode    2 Hermes    3 OpenClaw    Esc = atr\xE1s",
-  setupCta: "[S] Setup: instalar modelo + OpenCode / Hermes / OpenClaw",
-  machine: "EQUIPO",
-  runtimes: "RUNTIMES DE IA LOCAL",
-  installedModels: "MODELOS INSTALADOS",
-  compatible: "COMPATIBLES (cat\xE1logo, estimado)",
-  recommended: "RECOMENDADOS PARA ESTE EQUIPO",
-  recommendedHint: "Los valores estimados vienen de CanIRun.ai de midudev (canirun.ai \xB7 midu.dev) o de un fallback local \u2014 no son mediciones",
-  recommendKeys: "[\u2191\u2193] modelo  [I] ollama pull si nota S\u2013B  [O] OpenCode  [E] Hermes  [W] OpenClaw  [Esc] atr\xE1s",
-  recommendCliHint: "Instalar: npx pudu-ai recommend --install --yes   Vincular: npx pudu-ai recommend --link opencode --yes",
-  agentsTitle: "AGENTES DE C\xD3DIGO",
-  agentMissing: "no instalado \u2014 selecci\xF3nalo para instalar con ollama launch si el modelo es elegible",
-  installGradeBlock: "La nota {grade} es baja para hacer pull. Hace falta S, A o B.",
-  linkingTool: "Vinculando {tool} con {model}\u2026",
-  modelPulled: "Descargado {model} con Ollama.",
-  installNone: "Ning\xFAn modelo recomendado tiene nota S\u2013B para instalar.",
-  noOllamaTag: "No hay tag de Ollama para {model}. Nombres de cat\xE1logo como Agents-A1 no se pueden descargar. Usa qwen3:8b, gemma3:4b, qwen3.5:4b, llama3.1:8b.",
-  credits: "Medido: llama-bench + telemetr\xEDa del SO. Estimado: CanIRun.ai de midudev (https://canirun.ai, https://github.com/midudev/canirun.ai, https://midu.dev). Se etiquetan por separado; nunca se mezclan.",
-  noModels: "No se detectaron modelos locales",
-  notTested: "Sin probar",
-  detected: "detectado",
-  notDetected: "no detectado",
-  unknownMachine: "Equipo desconocido",
-  cpuNa: "CPU N/D",
-  selectBenchmark: "Selecciona un modelo para medir",
-  enterToRun: "Enter para ejecutar llama-bench  \xB7  Esc atr\xE1s",
-  noGguf: "No hay modelos GGUF resolubles para medir.",
-  performance: "RENDIMIENTO",
-  system: "SISTEMA",
-  powerThermals: "ENERG\xCDA / T\xC9RMICAS",
-  elapsed: "Transcurrido",
-  measuredAfter: "Los t/s de prompt y generaci\xF3n aparecen al terminar llama-bench (medidos).",
-  permissionsHint: "El % de GPU y la potencia requieren permisos extra; se muestra N/D si no se puede medir.",
-  cancelHint: "Ctrl+C / Q cancela llama-bench y la telemetr\xEDa",
-  saved: "Guardado",
-  hardwareHint: "Potencia, % de GPU y t\xE9rmicas requieren permisos extra del SO; si no hay datos se muestra N/D.",
-  modelsHint: "FIT y EST. SPEED son estimados. MEASURED sale del historial local de llama-bench.",
-  historyEmpty: "No hay historial de benchmarks en ~/.pudu-ai/benchmarks",
-  compareNeedTwo: "Se necesitan al menos dos benchmarks medidos para comparar.",
-  compareTitle: "BENCHMARKS LOCALES (medidos)",
-  winner: "Ganador",
-  qualityNote: "Calidad     (no se deriva de la velocidad; ver metadatos del cat\xE1logo)",
-  doctorTitle: "Pudu-AI Doctor",
-  doctorReady: "Listo para medir {count} modelos instalados.",
-  doctorNoBench: "llama-bench no est\xE1 disponible. Instala llama.cpp, p. ej. `brew install llama.cpp`. Pudu-AI no instala dependencias nativas.",
-  loading: "Inspeccionando hardware, runtimes y modelos locales\u2026",
-  addedPath: "Ruta de modelos a\xF1adida {path}",
-  modelNotFound: "Modelo no encontrado: {id}",
-  noHistory: "No hay historial de benchmarks.",
-  jsonNeedModel: "Pasa un id de modelo en modo JSON, p. ej. npx pudu-ai benchmark qwen3:8b --json",
-  useCaseCoding: "C\xF3digo",
-  useCaseGeneral: "General",
-  useCaseReasoning: "Razonamiento",
-  useCaseLightweight: "Ligero",
-  estimated: "Estimado",
-  measured: "Medido",
-  scoreLabel: "Puntuaci\xF3n Pudu-AI",
-  reportTitle: "Benchmark Pudu-AI",
-  benchmarkTitle: "Benchmark Pudu-AI",
-  tasksTitle: "HARNESSES DE TAREAS",
-  tasksHint: "Tareas peque\xF1as estilo OpenCode en tu idioma. Primero modelos instalados. El cat\xE1logo es Estimado (CanIRun.ai de midudev).",
-  tasksKinds: "Tipos de trabajo",
-  tasksScope: "Alcance",
-  tasksPriority: "Prioridad",
-  tasksInstalled: "instalado",
-  tasksNotInstalled: "no instalado",
-  tasksEmpty: "No hay modelos que coincidan con esos tipos de trabajo en este equipo.",
-  tasksQ1: "\xBFQu\xE9 quieres hacer? (espacio para marcar, enter para seguir)",
-  tasksQ2: "\xBFSolo modelos instalados, o tambi\xE9n estimaciones del cat\xE1logo?",
-  tasksQ3: "\xBFPrioridad?",
-  tasksOptCode: "C\xF3digo",
-  tasksOptVideo: "V\xEDdeo",
-  tasksOptImage: "Imagen",
-  tasksOptTranscription: "Transcripci\xF3n",
-  tasksOptChat: "Tareas / chat",
-  tasksOptInstalled: "Solo instalados",
-  tasksOptAll: "Instalados + cat\xE1logo (estimado)",
-  tasksOptSpeed: "Velocidad",
-  tasksOptBalanced: "Equilibrado",
-  tasksOptQuality: "Calidad",
-  taskCodeReviewTitle: "Revisar un diff local",
-  taskCodeReviewPrompt: "En OpenCode: abre un git diff y pide a este modelo bugs, tests faltantes y un resumen de 5 l\xEDneas. No apliques parches salvo que lo pidas.",
-  taskCodeTestsTitle: "Escribir un test que falle",
-  taskCodeTestsPrompt: "Elige una funci\xF3n. Pide un solo test Vitest/Jest que falle con el bug actual. No generes archivos extra.",
-  taskChatPlanTitle: "Convertir un objetivo en tareas",
-  taskChatPlanPrompt: "Dale un objetivo. Exige un plan numerado de 5 tareas tama\xF1o harness. Sin implementar todav\xEDa.",
-  taskChatAgentTitle: "Bucle de agente en un archivo",
-  taskChatAgentPrompt: "Se\xF1ala un archivo y un criterio de aceptaci\xF3n. Solo puede editar ese archivo y luego parar.",
-  taskImageCaptionTitle: "Describir una imagen local",
-  taskImageCaptionPrompt: "Si es un modelo de visi\xF3n/imagen, describe una imagen local en el idioma de la UI. Si es solo texto, indica N/D.",
-  taskImageBriefTitle: "Brief de generaci\xF3n de imagen",
-  taskImageBriefPrompt: "Pide un brief de 6 l\xEDneas (sujeto, lente, luz, negative prompt) para un still. No inventes que el modelo renderiz\xF3 la imagen.",
-  taskVideoBoardTitle: "Storyboard de 8 planos",
-  taskVideoBoardPrompt: "Pide 8 planos: duraci\xF3n, c\xE1mara, acci\xF3n, texto en pantalla. Local. No afirmes que existe un render.",
-  taskVideoShotTitle: "Lista de planos desde un guion",
-  taskVideoShotPrompt: "Pega un guion corto. Pide lista de planos y segundos estimados. Un modelo de texto puede planear; no puede encodear v\xEDdeo.",
-  taskTranscribeCleanTitle: "Limpiar una transcripci\xF3n",
-  taskTranscribeCleanPrompt: "Pega texto de speech-to-text ruidoso. Pide puntuaci\xF3n, quitar muletillas y mantener hablantes. Esto no es ASR; edita texto.",
-  taskTranscribeActionsTitle: "Acciones desde una transcripci\xF3n",
-  taskTranscribeActionsPrompt: "De una reuni\xF3n transcrita, extrae responsables, fechas y preguntas abiertas como checklist en el idioma de la UI.",
-  launchTitle: "INTEGRACIONES OLLAMA",
-  launchHint: "Por defecto solo explica. Pull/instalaci\xF3n/launch solo con --yes y solo si un modelo recomendado cabe en este hardware (nota S\u2013B; velocidad medida si existe). Docs: OpenCode, OpenClaw, Hermes, Claude Code v\xEDa Ollama.",
-  launchNeedOllama: "Ollama no est\xE1 detectado. Inst\xE1lalo primero. Pudu-AI no lo instala.",
-  launchNoModel: "Ning\xFAn modelo de c\xF3digo/chat en este equipo cumple el umbral de hardware para esta integraci\xF3n.",
-  launchGradeFail: "La nota {grade} est\xE1 por debajo del conjunto permitido ({allowed}).",
-  launchSlowFail: "Los {tps} t/s medidos est\xE1n por debajo del m\xEDnimo de agente ({min} t/s).",
-  launchEstimateWeak: "Solo hay una estimaci\xF3n d\xE9bil; no se har\xE1 pull ni launch.",
-  launchOk: "Elegible en este hardware para las tareas recomendadas.",
-  launchModel: "Modelo",
-  launchRunHint: "Para hacer pull (si hace falta) y lanzar: npx pudu-ai launch {tool} --yes",
-  launchBlocked: "Bloqueado. Sin pull, instalaci\xF3n ni launch.",
-  launchNeedTool: "Indica una herramienta: opencode | openclaw | hermes | claude",
-  launchUnknown: "Integraci\xF3n desconocida.",
-  launchPulling: "Descargando {model} con ollama pull\u2026",
-  launchPullFail: "Fall\xF3 ollama pull.",
-  launchExecFail: "Fall\xF3 ollama launch.",
-  help: `Pudu-AI \u2014 laboratorio local de hardware y benchmarks de IA
-
-Uso:
-  npx pudu-ai
-  npx pudu-ai hardware
-  npx pudu-ai models
-  npx pudu-ai models add-path ~/Models
-  npx pudu-ai setup
-  npx pudu-ai recommend
-  npx pudu-ai recommend --install --yes
-  npx pudu-ai recommend --link opencode --yes
-  npx pudu-ai tasks
-  npx pudu-ai tasks --for code,image --scope all --priority speed
-  npx pudu-ai benchmark [model]
-  npx pudu-ai compare
-  npx pudu-ai history
-  npx pudu-ai doctor
-  npx pudu-ai report --markdown
-  npx pudu-ai launch
-  npx pudu-ai launch opencode
-  npx pudu-ai launch opencode --yes
-
-Flags:
-  --json          JSON legible por m\xE1quinas (sin TUI)
-  --csv           Salida CSV
-  --no-network    Omite la API de CanIRun; usa cach\xE9/estimaciones locales
-  --no-color      Sin color ANSI
-  --verbose       Logs de depuraci\xF3n en stderr
-  --preset        quick | standard | stress
-  --lang          en | es
-  --for           code,video,image,transcription,chat
-  --scope         installed | all
-  --priority      speed | balanced | quality
-  --yes           Ejecuta pull/launch solo si el modelo es elegible
-
-Cr\xE9ditos:
-  Los valores medidos vienen de llama-bench y de la telemetr\xEDa del SO.
-  Los valores estimados vienen de CanIRun.ai de midudev
-  (https://canirun.ai \xB7 https://github.com/midudev/canirun.ai \xB7 https://midu.dev)
-  o de un fallback local, y se etiquetan como tal.
-`
-};
-
-// src/i18n/index.ts
-var locales = { en, es };
-var current = "en";
-function resolveLocale(raw) {
-  const value = (raw ?? process.env.PUDU_AI_LANG ?? process.env.PUDU_LANG ?? process.env.LANG ?? "en").toLowerCase();
-  if (value.startsWith("es")) return "es";
-  return "en";
-}
-function setLocale(locale) {
-  current = locale in locales ? locale : "en";
-}
-function t(id, vars) {
-  const table = locales[current] ?? locales.en;
-  let text = table[id] ?? locales.en[id];
-  if (vars) {
-    for (const [key, value] of Object.entries(vars)) {
-      text = text.replaceAll(`{${key}}`, String(value));
-    }
-  }
-  return text;
-}
-
-// src/integrations/ollama-tags.ts
-var RULES = [
-  { test: /qwen\s*3\.5\s*[-:]?\s*8b/i, tag: "qwen3.5:8b" },
-  { test: /qwen\s*3\.5\s*[-:]?\s*4b/i, tag: "qwen3.5:4b" },
-  { test: /qwen\s*3\s*[-:]?\s*14b/i, tag: "qwen3:14b" },
-  { test: /qwen\s*3\s*[-:]?\s*8b/i, tag: "qwen3:8b" },
-  { test: /qwen\s*3\s*[-:]?\s*4b/i, tag: "qwen3:4b" },
-  { test: /qwen\s*2\.5\s*[-:]?\s*coder\s*[-:]?\s*7b/i, tag: "qwen2.5-coder:7b" },
-  { test: /gemma\s*3\s*[-:]?\s*12b/i, tag: "gemma3:12b" },
-  { test: /gemma\s*3\s*[-:]?\s*4b/i, tag: "gemma3:4b" },
-  { test: /gemma\s*3\s*[-:]?\s*1b/i, tag: "gemma3:1b" },
-  { test: /llama\s*3\.2\s*[-:]?\s*3b/i, tag: "llama3.2:3b" },
-  { test: /llama\s*3\.2\s*[-:]?\s*1b/i, tag: "llama3.2:1b" },
-  { test: /llama\s*3\.1\s*[-:]?\s*8b/i, tag: "llama3.1:8b" },
-  { test: /deepseek[- ]r1\s*[-:]?\s*8b|deepseek-r1-distill.*8b/i, tag: "deepseek-r1:8b" },
-  { test: /deepseek[- ]r1\s*[-:]?\s*7b/i, tag: "deepseek-r1:7b" },
-  { test: /mistral\s*[-:]?\s*7b|mistral-nemo/i, tag: "mistral:7b" },
-  { test: /phi\s*4|phi-4/i, tag: "phi4" }
-];
-function resolveOllamaTag(...parts) {
-  const haystack = parts.filter(Boolean).join(" ");
-  if (!haystack.trim()) return void 0;
-  if (/^[a-z0-9._-]+:[a-z0-9._-]+$/i.test(haystack.trim())) return haystack.trim();
-  for (const rule of RULES) {
-    if (rule.test.test(haystack)) return rule.tag;
-  }
-  return void 0;
-}
-
-// src/compatibility/local.ts
-var GB_PER_BILLION_Q4 = 0.65;
-function estimateModelRamGb(model, quant = "Q4_K_M") {
-  const params = model.paramsBillions ?? 8;
-  const quantFactor = {
-    Q2_K: 0.4,
-    Q3_K_M: 0.5,
-    Q4_K_M: 0.65,
-    Q5_K_M: 0.8,
-    Q6_K: 0.9,
-    Q8_0: 1.1,
-    F16: 2
-  };
-  return params * (quantFactor[quant] ?? GB_PER_BILLION_Q4);
-}
-function localCompatibility(hardware, model) {
-  const ramGb = bytesToGiB(hardware.memory.totalBytes);
-  const required = estimateModelRamGb(model);
-  const ratio = required / ramGb;
-  let grade;
-  if (ratio <= 0.35) grade = "S";
-  else if (ratio <= 0.5) grade = "A";
-  else if (ratio <= 0.7) grade = "B";
-  else if (ratio <= 0.9) grade = "C";
-  else if (ratio <= 1.15) grade = "D";
-  else grade = "F";
-  const bandwidthGuess = hardware.cpu.appleSilicon ? 100 : 40;
-  const estimatedTokensPerSecond = grade === "F" ? void 0 : Math.max(4, bandwidthGuess / Math.max(required, 1));
-  return {
-    modelId: model.id,
-    source: "estimated",
-    grade,
-    estimatedRamGb: Number(required.toFixed(2)),
-    estimatedTokensPerSecond: estimatedTokensPerSecond ? Number(estimatedTokensPerSecond.toFixed(1)) : void 0,
-    notes: [`Local estimate from ${required.toFixed(1)} GB Q4 vs ${ramGb.toFixed(1)} GB ${hardware.memory.unified ? "unified memory" : "RAM"}`]
-  };
-}
-
 // src/compatibility/service.ts
 var FALLBACK_CATALOG = [
   { id: "gemma3-4b", name: "Gemma 3 4B", provider: "Google", paramsBillions: 4, useCase: ["chat"] },
@@ -1509,130 +657,13 @@ function labelUseCase(useCase) {
   return t("useCaseGeneral");
 }
 
-// src/storage/benchmarks.ts
-import { readdir as readdir2, readFile as readFile3, writeFile as writeFile3 } from "node:fs/promises";
-import path6 from "node:path";
-import { z as z3 } from "zod";
-var benchmarkRecordSchema = z3.object({
-  schemaVersion: z3.literal(1),
-  timestamp: z3.string(),
-  machine: z3.record(z3.unknown()),
-  model: z3.object({
-    id: z3.string(),
-    name: z3.string().optional(),
-    source: z3.string().optional(),
-    path: z3.string().optional()
-  }),
-  runtime: z3.object({
-    name: z3.string(),
-    command: z3.array(z3.string()).optional()
-  }),
-  benchmark: z3.object({
-    promptTokens: z3.number(),
-    generationTokens: z3.number(),
-    repetitions: z3.number(),
-    promptTokensPerSecond: z3.number().optional(),
-    generationTokensPerSecond: z3.number().optional(),
-    elapsedSeconds: z3.number().optional()
-  }),
-  resources: z3.object({
-    peakMemoryGb: z3.number().optional(),
-    peakSwapGb: z3.number().optional(),
-    avgGpuPercent: z3.number().optional(),
-    avgCpuPercent: z3.number().optional(),
-    peakGpuPercent: z3.number().optional(),
-    avgPackagePowerWatts: z3.number().optional(),
-    peakPackagePowerWatts: z3.number().optional(),
-    avgTemperatureC: z3.number().optional(),
-    peakTemperatureC: z3.number().optional(),
-    tokensPerSecondPerWatt: z3.number().optional(),
-    peakProcessRssGb: z3.number().optional()
-  }),
-  score: z3.object({
-    total: z3.number(),
-    speed: z3.string().optional(),
-    memory: z3.string().optional(),
-    energy: z3.string().optional(),
-    thermal: z3.string().optional(),
-    swap: z3.string().optional()
-  }).optional(),
-  origin: z3.enum(["measured"]).default("measured")
-});
-async function saveBenchmark(record) {
-  await ensureStorage();
-  const safeName = record.model.id.replace(/[^a-zA-Z0-9._-]+/g, "-");
-  const file = path6.join(benchmarksDir(), `${record.timestamp.replace(/[:.]/g, "-")}-${safeName}.json`);
-  await writeFile3(file, `${JSON.stringify(record, null, 2)}
-`, "utf8");
-  return file;
-}
-async function listBenchmarks() {
-  await ensureStorage();
-  let files = [];
-  try {
-    files = (await readdir2(benchmarksDir())).filter((f) => f.endsWith(".json"));
-  } catch {
-    return [];
-  }
-  const records = [];
-  for (const file of files.sort()) {
-    try {
-      const raw = await readFile3(path6.join(benchmarksDir(), file), "utf8");
-      records.push(benchmarkRecordSchema.parse(JSON.parse(raw)));
-    } catch {
-      continue;
-    }
-  }
-  return records;
-}
-
-// src/session/load.ts
-init_which();
-
-// src/integrations/agents.ts
-init_which();
-var AGENTS = [
-  {
-    id: "opencode",
-    label: "OpenCode",
-    bin: "opencode",
-    launch: "ollama launch opencode",
-    docs: "https://docs.ollama.com/integrations/opencode"
-  },
-  {
-    id: "hermes",
-    label: "Hermes",
-    bin: "hermes",
-    launch: "ollama launch hermes",
-    docs: "https://docs.ollama.com/integrations/hermes"
-  },
-  {
-    id: "openclaw",
-    label: "OpenClaw",
-    bin: "openclaw",
-    launch: "ollama launch openclaw",
-    docs: "https://docs.ollama.com/integrations/openclaw"
-  }
-];
-async function detectAgents() {
-  const out = [];
-  for (const agent of AGENTS) {
-    out.push({
-      ...agent,
-      detected: Boolean(await commandExists(agent.bin))
-    });
-  }
-  return out;
-}
-var DOCKER_OLLAMA = "docker run -d --name pudu-ollama -p 11434:11434 -v ollama:/root/.ollama ollama/ollama";
-
 // src/session/load.ts
 async function loadSession(options) {
   const hardware = await detectHardware();
   const [runtimes2, models, catalogState, history, llamaBench, agents] = await Promise.all([
     detectRuntimes(),
     discoverLocalModels(),
-    loadCatalog(options.network),
+    options.light ? Promise.resolve({ catalog: [], networkUsed: false }) : loadCatalog(options.network),
     listBenchmarks(),
     commandExists("llama-bench").then(Boolean),
     detectAgents()
@@ -1640,11 +671,11 @@ async function loadSession(options) {
   const rows = [];
   for (const local of models) {
     const catalog = matchCatalog(catalogState.catalog, local);
-    const compatibility = catalog ? await compatibilityFor(hardware, catalog, options.network) : void 0;
+    const compatibility = catalog && !options.light ? await compatibilityFor(hardware, catalog, options.network) : void 0;
     const lastBenchmark = [...history].reverse().find((b) => b.model.id === local.id);
     rows.push({ local, catalog, compatibility, lastBenchmark });
   }
-  const recommendations = await recommendForMachine(hardware, catalogState.catalog, options.network);
+  const recommendations = options.light ? [] : await recommendForMachine(hardware, catalogState.catalog, options.network);
   return {
     hardware,
     runtimes: runtimes2,
@@ -1659,1866 +690,11 @@ async function loadSession(options) {
   };
 }
 
-// src/benchmark/engine.ts
-init_process();
-init_which();
-
-// src/telemetry/macos.ts
-init_process();
-import os9 from "node:os";
-
-// src/telemetry/fallback.ts
-import os8 from "node:os";
-var previous = os8.cpus();
-function cpuPercent() {
-  const current2 = os8.cpus();
-  let idle = 0;
-  let total = 0;
-  for (let i = 0; i < current2.length; i += 1) {
-    const c = current2[i];
-    const p = previous[i] ?? c;
-    const idleDelta = c.times.idle - p.times.idle;
-    const totalDelta = c.times.user + c.times.nice + c.times.sys + c.times.idle + c.times.irq - (p.times.user + p.times.nice + p.times.sys + p.times.idle + p.times.irq);
-    idle += idleDelta;
-    total += totalDelta;
-  }
-  previous = current2;
-  if (total <= 0) return 0;
-  return Number((100 * (1 - idle / total)).toFixed(1));
-}
-var nodeTelemetry = {
-  async start() {
-    previous = os8.cpus();
-  },
-  async sample() {
-    const total = os8.totalmem();
-    const free = os8.freemem();
-    const sample = {
-      timestamp: Date.now(),
-      cpu: { utilizationPercent: cpuPercent() },
-      memory: {
-        usedBytes: total - free,
-        availableBytes: free,
-        swapUsedBytes: 0
-      }
-    };
-    return sample;
-  },
-  async stop() {
-    return;
-  }
-};
-
-// src/telemetry/macos.ts
-async function sampleProcess(pid) {
-  if (!pid) return void 0;
-  const result = await runCommand("ps", ["-o", "pid=,%cpu=,rss=", "-p", String(pid)], { timeout: 3e3 });
-  const parts = result.stdout.trim().split(/\s+/);
-  if (parts.length < 3) return { pid };
-  return {
-    pid,
-    cpuPercent: Number(parts[1]),
-    rssBytes: Number(parts[2]) * 1024
-  };
-}
-function createMacosTelemetry(pid) {
-  return {
-    async start() {
-      await nodeTelemetry.start();
-    },
-    async sample() {
-      const base = await nodeTelemetry.sample();
-      const [vm, pressure, pagesize, swap] = await Promise.all([
-        runCommand("vm_stat", [], { timeout: 3e3 }),
-        runCommand("memory_pressure", [], { timeout: 3e3 }),
-        runCommand("sysctl", ["-n", "hw.pagesize"], { timeout: 3e3 }),
-        runCommand("sysctl", ["-n", "vm.swapusage"], { timeout: 3e3 })
-      ]);
-      const pageSize = Number(pagesize.stdout.trim()) || 16384;
-      const parsed = parseMacosVmStat(vm.stdout, pageSize);
-      const total = os9.totalmem();
-      const available = parsed.availableBytes ?? os9.freemem();
-      const sample = {
-        ...base,
-        memory: {
-          usedBytes: Math.max(0, total - available),
-          availableBytes: available,
-          swapUsedBytes: parseMacosSwapUsage(swap.stdout) ?? 0
-        },
-        thermal: {
-          pressure: parseMacosMemoryPressure(pressure.stdout + pressure.stderr)
-        },
-        process: await sampleProcess(pid),
-        gpu: {
-          utilizationPercent: void 0,
-          powerWatts: void 0
-        }
-      };
-      return sample;
-    },
-    async stop() {
-      await nodeTelemetry.stop();
-    }
-  };
-}
-
-// src/telemetry/collector.ts
-function createTelemetry(pid) {
-  if (detectOs() === "macos") return createMacosTelemetry(pid);
-  return nodeTelemetry;
-}
-var TelemetryCollector = class {
-  provider;
-  timer;
-  samples = [];
-  running = false;
-  constructor(pid) {
-    this.provider = createTelemetry(pid);
-  }
-  async start(intervalMs = 750) {
-    await this.provider.start();
-    this.running = true;
-    const tick = async () => {
-      if (!this.running) return;
-      try {
-        const sample = await this.provider.sample();
-        this.samples.push(sample);
-        this.onSample?.(sample);
-      } catch {
-      }
-    };
-    await tick();
-    this.timer = setInterval(() => {
-      void tick();
-    }, intervalMs);
-  }
-  onSample;
-  latest() {
-    return this.samples.at(-1);
-  }
-  history() {
-    return this.samples;
-  }
-  async stop() {
-    this.running = false;
-    if (this.timer) clearInterval(this.timer);
-    await this.provider.stop();
-    return summarize(this.samples);
-  }
-};
-function summarize(samples) {
-  if (samples.length === 0) return { samples: 0 };
-  const avg = (values) => {
-    const nums = values.filter((v) => v !== void 0 && !Number.isNaN(v));
-    if (!nums.length) return void 0;
-    return Number((nums.reduce((a, b) => a + b, 0) / nums.length).toFixed(1));
-  };
-  const peak = (values) => {
-    const nums = values.filter((v) => v !== void 0 && !Number.isNaN(v));
-    if (!nums.length) return void 0;
-    return Number(Math.max(...nums).toFixed(2));
-  };
-  const GiB2 = 1024 ** 3;
-  return {
-    samples: samples.length,
-    avgCpuPercent: avg(samples.map((s) => s.cpu?.utilizationPercent)),
-    avgGpuPercent: avg(samples.map((s) => s.gpu?.utilizationPercent)),
-    peakGpuPercent: peak(samples.map((s) => s.gpu?.utilizationPercent)),
-    peakMemoryGb: peak(samples.map((s) => s.memory.usedBytes / GiB2)),
-    peakSwapGb: peak(samples.map((s) => s.memory.swapUsedBytes / GiB2)),
-    avgPackagePowerWatts: avg(samples.map((s) => s.packagePowerWatts ?? s.cpu?.powerWatts)),
-    peakPackagePowerWatts: peak(samples.map((s) => s.packagePowerWatts ?? s.cpu?.powerWatts)),
-    avgTemperatureC: avg(samples.map((s) => s.thermal?.temperatureC)),
-    peakTemperatureC: peak(samples.map((s) => s.thermal?.temperatureC)),
-    peakProcessRssGb: peak(samples.map((s) => (s.process?.rssBytes ?? 0) / GiB2))
-  };
-}
-
-// src/benchmark/parse-llama-bench.ts
-import { z as z4 } from "zod";
-var jsonRowSchema = z4.object({
-  n_prompt: z4.number().optional(),
-  n_gen: z4.number().optional(),
-  avg_ts: z4.number().optional(),
-  model_type: z4.string().optional(),
-  model_size: z4.number().optional(),
-  backends: z4.string().optional(),
-  test: z4.string().optional()
-}).passthrough();
-function parseLlamaBenchJson(text) {
-  const parsed = JSON.parse(text);
-  const rows = Array.isArray(parsed) ? parsed.map((row) => jsonRowSchema.parse(row)) : [jsonRowSchema.parse(parsed)];
-  return metricsFromRows(rows, parsed);
-}
-function metricsFromRows(rows, raw) {
-  let promptTokensPerSecond;
-  let generationTokensPerSecond;
-  for (const row of rows) {
-    const test = row.test ?? "";
-    const avg = row.avg_ts;
-    if (avg === void 0) continue;
-    if (/^pp/i.test(test) || (row.n_prompt ?? 0) > 0 && (row.n_gen ?? 0) === 0) {
-      promptTokensPerSecond = avg;
-    } else if (/^tg/i.test(test) || (row.n_gen ?? 0) > 0 && (row.n_prompt ?? 0) === 0) {
-      generationTokensPerSecond = avg;
-    }
-  }
-  const first = rows[0];
-  return {
-    promptTokensPerSecond,
-    generationTokensPerSecond,
-    modelType: first?.model_type,
-    modelSizeBytes: first?.model_size,
-    backend: first?.backends,
-    raw
-  };
-}
-function parseLlamaBenchMarkdown(text) {
-  const rows = [];
-  for (const line of text.split(/\r?\n/)) {
-    if (!line.includes("|")) continue;
-    const cells = line.split("|").map((c) => c.trim()).filter(Boolean);
-    if (cells.length < 6) continue;
-    if (/^model$/i.test(cells[0] ?? "") || /^-+$/.test(cells[0] ?? "")) continue;
-    const test = cells[cells.length - 2] ?? "";
-    const tsCell = cells[cells.length - 1] ?? "";
-    const tsMatch = tsCell.match(/([\d.]+)/);
-    if (!tsMatch) continue;
-    rows.push({ test, ts: Number(tsMatch[1]), modelType: cells[0] });
-  }
-  let promptTokensPerSecond;
-  let generationTokensPerSecond;
-  for (const row of rows) {
-    if (/^pp/i.test(row.test)) promptTokensPerSecond = row.ts;
-    if (/^tg/i.test(row.test)) generationTokensPerSecond = row.ts;
-  }
-  return {
-    promptTokensPerSecond,
-    generationTokensPerSecond,
-    modelType: rows[0]?.modelType,
-    raw: { format: "markdown", rows }
-  };
-}
-function parseLlamaBenchOutput(text) {
-  const trimmed = text.trim();
-  const jsonStart = trimmed.indexOf("[");
-  const jsonObjStart = trimmed.indexOf("{");
-  const start = jsonStart >= 0 && (jsonObjStart < 0 || jsonStart < jsonObjStart) ? jsonStart : jsonObjStart;
-  if (start >= 0) {
-    const slice = trimmed.slice(start);
-    try {
-      return parseLlamaBenchJson(slice);
-    } catch {
-    }
-  }
-  return parseLlamaBenchMarkdown(text);
-}
-function tokensPerSecondPerWatt(tokensPerSecond, watts) {
-  if (!tokensPerSecond || !watts || watts <= 0) return void 0;
-  return Number((tokensPerSecond / watts).toFixed(2));
-}
-
-// src/benchmark/presets.ts
-var PRESETS = {
-  quick: { name: "quick", promptTokens: 512, generationTokens: 128, repetitions: 3 },
-  standard: { name: "standard", promptTokens: 2048, generationTokens: 256, repetitions: 5 },
-  stress: { name: "stress", promptTokens: 4096, generationTokens: 512, repetitions: 10 }
-};
-function resolvePreset(name) {
-  if (name === "standard" || name === "stress" || name === "quick") return PRESETS[name];
-  return PRESETS.quick;
-}
-
-// src/compatibility/grades.ts
-function gradeFromThresholds(score, thresholds) {
-  if (score >= thresholds.S) return "S";
-  if (score >= thresholds.A) return "A";
-  if (score >= thresholds.B) return "B";
-  if (score >= thresholds.C) return "C";
-  if (score >= thresholds.D) return "D";
-  return "F";
-}
-function gradeToScore(grade) {
-  return { S: 100, A: 85, B: 70, C: 55, D: 40, F: 20 }[grade];
-}
-
-// src/benchmark/score.ts
-function computeLocalMeterScore(generationTokensPerSecond, resources, totalMemoryGb) {
-  const dimensions = [
-    {
-      key: "speed",
-      measured: generationTokensPerSecond !== void 0,
-      grade: generationTokensPerSecond === void 0 ? void 0 : gradeFromThresholds(generationTokensPerSecond, { S: 60, A: 40, B: 25, C: 12, D: 5, F: 0 }),
-      weight: 35
-    },
-    {
-      key: "memory",
-      measured: resources.peakMemoryGb !== void 0 && totalMemoryGb > 0,
-      grade: resources.peakMemoryGb === void 0 || totalMemoryGb <= 0 ? void 0 : gradeFromThresholds(100 - resources.peakMemoryGb / totalMemoryGb * 100, {
-        S: 50,
-        A: 30,
-        B: 15,
-        C: 5,
-        D: 0,
-        F: -100
-      }),
-      weight: 25
-    },
-    {
-      key: "energy",
-      measured: resources.avgPackagePowerWatts !== void 0 && generationTokensPerSecond !== void 0,
-      grade: energyGrade(generationTokensPerSecond, resources.avgPackagePowerWatts),
-      weight: 20
-    },
-    {
-      key: "thermal",
-      measured: resources.peakTemperatureC !== void 0,
-      grade: resources.peakTemperatureC === void 0 ? void 0 : gradeFromThresholds(100 - resources.peakTemperatureC, { S: 30, A: 20, B: 10, C: 0, D: -10, F: -100 }),
-      weight: 10
-    },
-    {
-      key: "swap",
-      measured: resources.peakSwapGb !== void 0,
-      grade: resources.peakSwapGb === void 0 ? void 0 : gradeFromThresholds(4 - resources.peakSwapGb, { S: 4, A: 3.75, B: 3, C: 2, D: 0, F: -100 }),
-      weight: 10
-    }
-  ];
-  const measured = dimensions.filter((d) => d.measured && d.grade);
-  const weightSum = measured.reduce((sum, d) => sum + d.weight, 0);
-  if (!measured.length || weightSum === 0) return { dimensions };
-  const total = measured.reduce((sum, d) => sum + gradeToScore(d.grade) * (d.weight / weightSum), 0);
-  return { total: Math.round(total), dimensions };
-}
-function energyGrade(tps, watts) {
-  if (!tps || !watts || watts <= 0) return void 0;
-  const efficiency = tps / watts;
-  return gradeFromThresholds(efficiency, { S: 3, A: 2, B: 1.2, C: 0.6, D: 0.3, F: 0 });
-}
-
-// src/benchmark/assess.ts
-function assessRun(input) {
-  const lines = [];
-  const { generationTokensPerSecond, resources, catalog } = input;
-  if (generationTokensPerSecond !== void 0 && generationTokensPerSecond >= 25) {
-    lines.push("Runs comfortably on this machine");
-  } else if (generationTokensPerSecond !== void 0 && generationTokensPerSecond >= 10) {
-    lines.push("Runs, but generation is constrained");
-  } else if (generationTokensPerSecond !== void 0) {
-    lines.push("Generation is too slow for interactive use");
-  }
-  if ((resources.peakSwapGb ?? 0) < 0.05) lines.push("No meaningful swap detected");
-  else lines.push("Swap activity detected \u2014 memory is tight");
-  if (resources.avgGpuPercent !== void 0 && resources.avgGpuPercent >= 80) {
-    lines.push("GPU remains highly utilized (system-wide)");
-  }
-  if (generationTokensPerSecond !== void 0 && generationTokensPerSecond >= 35) {
-    lines.push("Good sustained generation performance");
-  }
-  if (resources.avgPackagePowerWatts !== void 0 && generationTokensPerSecond) {
-    const eff = generationTokensPerSecond / resources.avgPackagePowerWatts;
-    if (eff >= 2) lines.push("Excellent energy efficiency");
-  }
-  if (catalog?.useCase?.length) {
-    lines.push(`This model is suitable for: ${catalog.useCase.join(", ")}`);
-  }
-  return lines;
-}
-
-// src/benchmark/engine.ts
-async function runBenchmark(input) {
-  const bench = await commandExists("llama-bench");
-  if (!bench) {
-    throw new Error("llama-bench not found. Install llama.cpp (e.g. brew install llama.cpp).");
-  }
-  const artifact = input.model.artifactPath;
-  if (!artifact) {
-    throw new Error(`No GGUF path for ${input.model.id}. Cannot run llama-bench.`);
-  }
-  const preset = resolvePreset(input.preset);
-  const started = Date.now();
-  const args2 = [
-    "-m",
-    artifact,
-    "-p",
-    String(preset.promptTokens),
-    "-n",
-    String(preset.generationTokens),
-    "-r",
-    String(preset.repetitions),
-    "-o",
-    "json"
-  ];
-  const subprocess = spawnTracked(bench, args2, { timeout: 30 * 6e4 });
-  const collector = new TelemetryCollector(subprocess.pid);
-  collector.onSample = (sample) => {
-    input.onProgress?.({ sample, elapsedSeconds: (Date.now() - started) / 1e3, status: "running" });
-  };
-  await collector.start(750);
-  const abort = () => {
-    subprocess.kill("SIGTERM");
-  };
-  input.signal?.addEventListener("abort", abort, { once: true });
-  const result = await subprocess;
-  input.signal?.removeEventListener("abort", abort);
-  const resources = await collector.stop();
-  if (input.signal?.aborted) {
-    throw new Error("Benchmark cancelled");
-  }
-  const stdout = toText(result.stdout);
-  const stderr = toText(result.stderr);
-  if (result.exitCode !== 0) {
-    throw new Error(stderr || `llama-bench exited with ${result.exitCode}`);
-  }
-  const metrics = parseLlamaBenchOutput(stdout || stderr);
-  const score = computeLocalMeterScore(
-    metrics.generationTokensPerSecond,
-    resources,
-    bytesToGiB(input.hardware.memory.totalBytes)
-  );
-  const efficiency = tokensPerSecondPerWatt(
-    metrics.generationTokensPerSecond,
-    resources.avgPackagePowerWatts
-  );
-  const record = {
-    schemaVersion: 1,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    machine: {
-      os: input.hardware.os,
-      arch: input.hardware.arch,
-      model: input.hardware.machineModel,
-      cpu: input.hardware.cpu.name,
-      memoryGb: Number(bytesToGiB(input.hardware.memory.totalBytes).toFixed(1)),
-      unified: input.hardware.memory.unified
-    },
-    model: {
-      id: input.model.id,
-      name: input.model.name,
-      source: input.model.source,
-      path: input.model.artifactPath
-    },
-    runtime: { name: "llama-bench", command: [bench, ...args2] },
-    benchmark: {
-      promptTokens: preset.promptTokens,
-      generationTokens: preset.generationTokens,
-      repetitions: preset.repetitions,
-      promptTokensPerSecond: metrics.promptTokensPerSecond,
-      generationTokensPerSecond: metrics.generationTokensPerSecond,
-      elapsedSeconds: (Date.now() - started) / 1e3
-    },
-    resources: {
-      ...resourceFields(resources),
-      tokensPerSecondPerWatt: efficiency
-    },
-    score: {
-      total: score.total ?? 0,
-      speed: score.dimensions.find((d) => d.key === "speed")?.grade,
-      memory: score.dimensions.find((d) => d.key === "memory")?.grade,
-      energy: score.dimensions.find((d) => d.key === "energy")?.grade,
-      thermal: score.dimensions.find((d) => d.key === "thermal")?.grade,
-      swap: score.dimensions.find((d) => d.key === "swap")?.grade
-    },
-    origin: "measured"
-  };
-  const path7 = await saveBenchmark(record);
-  input.onProgress?.({
-    elapsedSeconds: record.benchmark.elapsedSeconds ?? 0,
-    status: "completed"
-  });
-  return {
-    record,
-    assessment: assessRun({
-      generationTokensPerSecond: metrics.generationTokensPerSecond,
-      resources,
-      catalog: input.catalog
-    }),
-    path: path7,
-    stdout
-  };
-}
-function resourceFields(resources) {
-  return {
-    peakMemoryGb: resources.peakMemoryGb,
-    peakSwapGb: resources.peakSwapGb,
-    avgGpuPercent: resources.avgGpuPercent,
-    avgCpuPercent: resources.avgCpuPercent,
-    peakGpuPercent: resources.peakGpuPercent,
-    avgPackagePowerWatts: resources.avgPackagePowerWatts,
-    peakPackagePowerWatts: resources.peakPackagePowerWatts,
-    avgTemperatureC: resources.avgTemperatureC,
-    peakTemperatureC: resources.peakTemperatureC,
-    peakProcessRssGb: resources.peakProcessRssGb
-  };
-}
-
-// src/cli/run.ts
-init_process();
-
-// src/shared/logger.ts
-var level = "info";
-function setLogLevel(next) {
-  level = next;
-}
-
-// src/tui/render.tsx
-import { render } from "ink";
-
-// src/tui/App.tsx
-import { Box as Box11, useApp as useApp2, useInput as useInput4 } from "ink";
-import { useMemo as useMemo2, useRef as useRef2, useState as useState5 } from "react";
-
-// src/tui/views/Dashboard.tsx
-import { Box, Text as Text2 } from "ink";
-
-// src/shared/format.ts
-function formatNumber(value, digits = 1) {
-  if (value === void 0 || Number.isNaN(value)) return "N/A";
-  return value.toFixed(digits);
-}
-function formatPercent(value, digits = 0) {
-  if (value === void 0 || Number.isNaN(value)) return "N/A";
-  return `${value.toFixed(digits)} %`;
-}
-function formatTokensPerSec(value, digits = 1) {
-  if (value === void 0 || Number.isNaN(value)) return "N/A";
-  return `${value.toFixed(digits)} t/s`;
-}
-function na(value) {
-  if (value === void 0 || value === null || value === "") return "N/A";
-  return String(value);
-}
-
-// src/hardware/types.ts
-function memoryLabel(profile) {
-  return profile.memory.unified ? "Unified Memory" : "RAM";
-}
-
-// src/tui/theme.ts
-function gradeColor(grade) {
-  if (grade === "S" || grade === "A") return "green";
-  if (grade === "B") return "yellow";
-  if (grade === "C") return "magenta";
-  if (grade === "D" || grade === "F") return "red";
-  return "gray";
-}
-function bar(percent, width = 10) {
-  if (percent === void 0 || Number.isNaN(percent)) return `${"\u2591".repeat(width)} N/A`;
-  const filled = Math.max(0, Math.min(width, Math.round(percent / 100 * width)));
-  return `${"\u2588".repeat(filled)}${"\u2591".repeat(width - filled)}`;
-}
-function sparkline(values, width = 24) {
-  const glyphs = ["\u2581", "\u2582", "\u2583", "\u2584", "\u2585", "\u2586", "\u2587", "\u2588"];
-  if (!values.length) return glyphs[0].repeat(width);
-  const slice = values.slice(-width);
-  const max = Math.max(...slice, 1);
-  return slice.map((v) => glyphs[Math.min(glyphs.length - 1, Math.floor(v / max * (glyphs.length - 1)))]).join("").padStart(width, glyphs[0]);
-}
-
-// src/tui/Typewriter.tsx
-import { Text } from "ink";
-import { useEffect, useState } from "react";
-import { jsx, jsxs } from "react/jsx-runtime";
-var finished = /* @__PURE__ */ new Set();
-function Typewriter(props) {
-  const start = props.once && finished.has(props.text) ? props.text.length : 0;
-  const [n, setN] = useState(start);
-  useEffect(() => {
-    if (props.once && finished.has(props.text)) {
-      setN(props.text.length);
-      return;
-    }
-    setN(0);
-  }, [props.text, props.once]);
-  useEffect(() => {
-    if (n >= props.text.length) return;
-    const timer = setTimeout(() => {
-      setN((v) => {
-        const next = v + 1;
-        if (props.once && next >= props.text.length) finished.add(props.text);
-        return next;
-      });
-    }, props.ms ?? 16);
-    return () => clearTimeout(timer);
-  }, [n, props.text, props.ms, props.once]);
-  const done = n >= props.text.length;
-  return /* @__PURE__ */ jsxs(Text, { color: props.color, dimColor: props.dimColor, bold: props.bold, children: [
-    props.text.slice(0, n),
-    done ? null : /* @__PURE__ */ jsx(Text, { color: "cyan", bold: true, children: "\u258D" })
-  ] });
-}
-
-// src/tui/width.ts
-import { useStdout } from "ink";
-function useCols() {
-  const { stdout } = useStdout();
-  const cols = stdout?.columns ?? 80;
-  return Math.max(40, Math.min(cols - 2, 100));
-}
-function fit(text, width) {
-  if (text.length <= width) return text;
-  if (width <= 1) return "\u2026";
-  return `${text.slice(0, width - 1)}\u2026`;
-}
-
-// src/tui/views/Dashboard.tsx
-import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
-function Dashboard({ session }) {
-  const cols = useCols();
-  const h = session.hardware;
-  const line = fit(
-    `${h.machineModel ?? t("unknownMachine")} \xB7 ${h.cpu.name ?? t("cpuNa")} \xB7 ${formatBytes(h.memory.totalBytes, 0)} ${memoryLabel(h)}`,
-    cols
-  );
-  return /* @__PURE__ */ jsxs2(Box, { flexDirection: "column", width: cols, children: [
-    /* @__PURE__ */ jsx2(Text2, { bold: true, color: "cyan", children: t("machine") }),
-    /* @__PURE__ */ jsx2(Text2, { children: line }),
-    /* @__PURE__ */ jsx2(Text2, { children: session.runtimes.map((r, i) => /* @__PURE__ */ jsxs2(Text2, { color: r.detected ? "green" : "gray", children: [
-      i ? " " : "",
-      r.detected ? "\u2713" : "\u25CB",
-      r.label
-    ] }, r.id)) }),
-    /* @__PURE__ */ jsx2(Text2, { bold: true, color: "cyan", children: t("installedModels") }),
-    session.rows.length === 0 && /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: t("noModels") }),
-    session.rows.slice(0, 6).map((row) => /* @__PURE__ */ jsxs2(Text2, { children: [
-      /* @__PURE__ */ jsx2(Text2, { color: "green", children: fit(row.local.name, 18) }),
-      /* @__PURE__ */ jsx2(Text2, { children: " " }),
-      /* @__PURE__ */ jsx2(Text2, { color: gradeColor(row.compatibility?.grade), children: row.compatibility?.grade ?? "\u2014" }),
-      /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
-        " ",
-        row.lastBenchmark?.benchmark.generationTokensPerSecond ? formatTokensPerSec(row.lastBenchmark.benchmark.generationTokensPerSecond) : t("notTested")
-      ] })
-    ] }, row.local.id)),
-    /* @__PURE__ */ jsx2(Text2, { bold: true, color: "cyan", children: t("recommended") }),
-    session.recommendations.slice(0, 4).map((rec) => /* @__PURE__ */ jsxs2(Text2, { children: [
-      /* @__PURE__ */ jsx2(Text2, { color: "magenta", children: fit(rec.useCase, 10) }),
-      /* @__PURE__ */ jsxs2(Text2, { children: [
-        " ",
-        fit(rec.model.name, 22),
-        " "
-      ] }),
-      /* @__PURE__ */ jsx2(Text2, { color: gradeColor(rec.grade), children: rec.grade })
-    ] }, `${rec.useCase}-${rec.model.id}`)),
-    /* @__PURE__ */ jsxs2(Text2, { children: [
-      /* @__PURE__ */ jsx2(Text2, { color: session.runtimes.find((r) => r.id === "ollama")?.detected ? "green" : "yellow", children: session.runtimes.find((r) => r.id === "ollama")?.detected ? "\u2713 Ollama" : `\u25CB Ollama ${t("reqOllama")}` }),
-      /* @__PURE__ */ jsx2(Text2, { children: "  " }),
-      /* @__PURE__ */ jsx2(Text2, { color: session.runtimes.find((r) => r.id === "lmstudio")?.detected ? "green" : "gray", children: session.runtimes.find((r) => r.id === "lmstudio")?.detected ? "\u2713 LM Studio" : `\u25CB LM Studio ${t("reqLmStudio")}` })
-    ] }),
-    /* @__PURE__ */ jsx2(Typewriter, { text: fit(t("setupCta"), cols), ms: 18, color: "yellow" })
-  ] });
-}
-
-// src/tui/views/Models.tsx
-import { Box as Box2, Text as Text3 } from "ink";
-
-// src/compatibility/types.ts
-var GRADE_MEANING = {
-  S: "Excellent",
-  A: "Recommended",
-  B: "Good",
-  C: "Tight",
-  D: "CPU/offload",
-  F: "Not recommended"
-};
-
-// src/cli/color.ts
-var enabled = () => !process.env.NO_COLOR && process.stdout.isTTY;
-var wrap = (open, close = 39) => (text) => enabled() ? `\x1B[${open}m${text}\x1B[${close}m` : text;
-var cyan = wrap(36);
-var green = wrap(32);
-var yellow = wrap(33);
-var red = wrap(31);
-var magenta = wrap(35);
-var bold = wrap(1, 22);
-var dim = wrap(2, 22);
-function gradeAnsi(grade) {
-  if (grade === "S" || grade === "A") return green(grade);
-  if (grade === "B") return yellow(grade);
-  if (grade === "C") return magenta(grade);
-  if (grade === "D" || grade === "F") return red(grade);
-  return grade;
-}
-
-// src/cli/text.ts
-function hardwareText(session) {
-  const h = session.hardware;
-  const ram = formatBytes(h.memory.totalBytes, 0);
-  const avail = h.memory.availableBytes ? formatBytes(h.memory.availableBytes) : "N/A";
-  return [
-    bold(cyan(t("machine"))),
-    `  ${h.machineModel ?? t("unknownMachine")}`,
-    `  ${h.cpu.name ?? t("cpuNa")}`,
-    `  CPU           ${h.cpu.physicalCores ?? "N/A"} cores (${h.cpu.performanceCores ?? "?"}P / ${h.cpu.efficiencyCores ?? "?"}E)`,
-    `  GPU           ${h.gpu.name ?? "N/A"}`,
-    `  ${memoryLabel(h).padEnd(13)} ${ram}`,
-    `  Available     ${avail}`,
-    `  ${h.os}         ${h.osVersion ?? h.arch}`
-  ].join("\n");
-}
-function runtimesText(session) {
-  return [
-    bold(cyan(t("runtimes"))),
-    ...session.runtimes.map((r) => {
-      const mark = r.detected ? green("\u2713") : dim("\u25CB");
-      const state = r.detected ? green(r.version ?? t("detected")) : dim(t("notDetected"));
-      return `  ${mark} ${r.label.padEnd(14)} ${state}`;
-    })
-  ].join("\n");
-}
-function modelsText(session) {
-  const lines = [bold(cyan(t("installedModels"))), dim("MODEL                 INSTALLED   FIT       EST. SPEED     MEASURED")];
-  for (const row of session.rows) {
-    const fit2 = row.compatibility?.grade ?? "\u2014";
-    const est = row.compatibility?.estimatedTokensPerSecond ? `~${formatNumber(row.compatibility.estimatedTokensPerSecond)} t/s` : "\u2014";
-    const measured = row.lastBenchmark?.benchmark.generationTokensPerSecond ? formatTokensPerSec(row.lastBenchmark.benchmark.generationTokensPerSecond) : t("notTested");
-    lines.push(
-      `${green(row.local.name.padEnd(22))} \u2713           ${gradeAnsi(fit2).padEnd(9)} ${est.padEnd(14)} ${measured}`
-    );
-  }
-  lines.push("", t("compatible"));
-  const extras = session.catalog.filter((model) => !session.rows.some((row) => idsLikelyMatch(row.local.id, model.id))).map((model) => ({ model, fit: localCompatibility(session.hardware, model) })).sort((a, b) => a.fit.grade.localeCompare(b.fit.grade)).slice(0, 12);
-  for (const extra of extras) {
-    const est = extra.fit.estimatedTokensPerSecond ? `~${formatNumber(extra.fit.estimatedTokensPerSecond)} t/s` : "\u2014";
-    lines.push(`${extra.model.name.padEnd(22)} \u2014           ${extra.fit.grade.padEnd(9)} ${est.padEnd(14)} ${t("estimated")}`);
-  }
-  return lines.join("\n");
-}
-function recommendText(session) {
-  const lines = [bold(cyan(t("recommended"))), dim(t("recommendedHint")), "", dim(t("credits")), ""];
-  for (const rec of session.recommendations) {
-    lines.push(
-      `${magenta(rec.useCase.padEnd(12))} ${rec.model.name.padEnd(22)} ${gradeAnsi(rec.grade)}  ${GRADE_MEANING[rec.grade]}  ~${na(rec.estimatedTokensPerSecond)} t/s est.`
-    );
-  }
-  lines.push("", bold(yellow(t("agentsTitle"))));
-  for (const agent of session.agents) {
-    lines.push(
-      `  ${agent.detected ? green("\u2713") : dim("\u25CB")} ${agent.label.padEnd(12)} ${agent.detected ? green(t("detected")) : dim(t("agentMissing"))}`
-    );
-  }
-  lines.push("", dim(t("recommendCliHint")));
-  return lines.join("\n");
-}
-function historyText(records) {
-  if (!records.length) return t("historyEmpty");
-  return records.map((r) => {
-    const gen = r.benchmark.generationTokensPerSecond;
-    return `${r.timestamp}  ${r.model.id.padEnd(18)}  ${gen ? formatTokensPerSec(gen) : "N/A"}  score ${r.score?.total ?? "N/A"}`;
-  }).join("\n");
-}
-function historyCsv(records) {
-  const header = "timestamp,model,prompt_tps,generation_tps,peak_memory_gb,avg_cpu,score";
-  const rows = records.map(
-    (r) => [
-      r.timestamp,
-      r.model.id,
-      r.benchmark.promptTokensPerSecond ?? "",
-      r.benchmark.generationTokensPerSecond ?? "",
-      r.resources.peakMemoryGb ?? "",
-      r.resources.avgCpuPercent ?? "",
-      r.score?.total ?? ""
-    ].join(",")
-  );
-  return [header, ...rows].join("\n");
-}
-function doctorText(session) {
-  const node = process.version.replace(/^v/, "");
-  const apple = session.hardware.cpu.appleSilicon ? `${session.hardware.cpu.appleSilicon.generation} ${session.hardware.cpu.appleSilicon.variant}` : "no";
-  const lines = [
-    t("doctorTitle"),
-    "",
-    `\u2713 Node.js       ${node}`,
-    `${session.hardware.cpu.appleSilicon ? "\u2713" : "\u25CB"} Apple Silicon ${apple}`,
-    `${session.hardware.gpu.metal ? "\u2713" : "\u25CB"} Metal`,
-    ...session.runtimes.map((r) => `${r.detected ? "\u2713" : "\u25CB"} ${r.label.padEnd(14)} ${r.version ?? ""}`.trimEnd()),
-    `${session.networkUsed ? "\u2713" : "\u25CB"} CanIRun.ai (midudev)`,
-    ...session.agents.map(
-      (a) => `${a.detected ? "\u2713" : "\u25CB"} ${a.label.padEnd(14)} ${a.detected ? t("detected") : a.launch}`
-    ),
-    ...session.runtimes.find((r) => r.id === "ollama")?.detected ? [] : [`\u25CB Ollama        ${t("reqOllama")}`],
-    ...session.runtimes.find((r) => r.id === "lmstudio")?.detected ? [] : [`\u25CB LM Studio     ${t("reqLmStudio")}`],
-    ...session.runtimes.find((r) => r.id === "docker")?.detected ? [`\u2713 Docker         ${t("dockerHint")}`] : [`\u25CB Docker        ${t("reqDocker")}`],
-    "",
-    session.llamaBench ? t("doctorReady", { count: session.models.filter((m) => m.artifactPath).length }) : t("doctorNoBench")
-  ];
-  return lines.join("\n");
-}
-function reportMarkdown(record) {
-  const machine = `${record.machine.cpu ?? "unknown"} / ${record.machine.memoryGb ?? "?"} GB`;
-  return `## ${t("reportTitle")}
-
-**Machine:** ${machine}
-**Model:** ${record.model.id}
-
-| Metric | Result |
-|---|---:|
-| Prompt processing | ${record.benchmark.promptTokensPerSecond ?? "N/A"} t/s |
-| Generation | ${record.benchmark.generationTokensPerSecond ?? "N/A"} t/s |
-| Peak memory | ${record.resources.peakMemoryGb ?? "N/A"} GB |
-| Average GPU | ${record.resources.avgGpuPercent ?? "N/A"}% |
-| Average power | ${record.resources.avgPackagePowerWatts ?? "N/A"} W |
-| Efficiency | ${record.resources.tokensPerSecondPerWatt ?? "N/A"} t/s/W |
-| ${t("scoreLabel")} | ${record.score?.total ?? "N/A"} / 100 |
-`;
-}
-function compareText(records) {
-  const latestByModel = /* @__PURE__ */ new Map();
-  for (const record of records) latestByModel.set(record.model.id, record);
-  const list = [...latestByModel.values()].slice(0, 4);
-  if (list.length < 2) return t("compareNeedTwo");
-  const names = list.map((r) => r.model.id);
-  const row = (label, pick) => `${label.padEnd(20)}${list.map((r) => pick(r).padStart(14)).join("")}`;
-  const winner = (metric, higher = true) => {
-    let best;
-    for (const r of list) {
-      const v = metric(r);
-      if (v === void 0) continue;
-      if (!best) best = r;
-      else {
-        const b = metric(best);
-        if (b === void 0) best = r;
-        else if (higher ? v > b : v < b) best = r;
-      }
-    }
-    return best?.model.id ?? "N/A";
-  };
-  return [
-    t("compareTitle"),
-    names.join(" vs "),
-    row("Generation t/s", (r) => formatNumber(r.benchmark.generationTokensPerSecond)),
-    row("Prompt t/s", (r) => formatNumber(r.benchmark.promptTokensPerSecond)),
-    row("Peak RAM", (r) => r.resources.peakMemoryGb ? `${r.resources.peakMemoryGb} GB` : "N/A"),
-    row("Avg CPU", (r) => r.resources.avgCpuPercent ? `${r.resources.avgCpuPercent}%` : "N/A"),
-    row("Power", (r) => r.resources.avgPackagePowerWatts ? `${r.resources.avgPackagePowerWatts} W` : "N/A"),
-    row("t/s/W", (r) => formatNumber(r.resources.tokensPerSecondPerWatt)),
-    "",
-    t("winner"),
-    `Speed       ${winner((r) => r.benchmark.generationTokensPerSecond)}`,
-    `Memory      ${winner((r) => r.resources.peakMemoryGb, false)}`,
-    `Efficiency  ${winner((r) => r.resources.tokensPerSecondPerWatt)}`,
-    t("qualityNote")
-  ].join("\n");
-}
-function resultText(record, assessment) {
-  return [
-    record.model.id,
-    "",
-    `Prompt processing       ${record.benchmark.promptTokensPerSecond ?? "N/A"} t/s`,
-    `Generation               ${record.benchmark.generationTokensPerSecond ?? "N/A"} t/s`,
-    `Peak memory               ${record.resources.peakMemoryGb ?? "N/A"} GB`,
-    `Average GPU                ${record.resources.avgGpuPercent ?? "N/A"} %`,
-    `Average CPU                ${record.resources.avgCpuPercent ?? "N/A"} %`,
-    `Average power              ${record.resources.avgPackagePowerWatts ?? "N/A"} W`,
-    `Efficiency                ${record.resources.tokensPerSecondPerWatt ?? "N/A"} t/s/W`,
-    "",
-    `${t("scoreLabel")}          ${record.score?.total ?? "N/A"}/100`,
-    "",
-    ...assessment.map((line) => `\u2713 ${line}`)
-  ].join("\n");
-}
-
-// src/tui/views/Models.tsx
-import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
-function ModelsView({ session }) {
-  return /* @__PURE__ */ jsxs3(Box2, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx3(Text3, { children: modelsText(session) }),
-    /* @__PURE__ */ jsx3(Text3, { color: "yellow", children: t("modelsHint") })
-  ] });
-}
-
-// src/tui/views/Hardware.tsx
-import { Box as Box3, Text as Text4 } from "ink";
-import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
-function HardwareView({ session }) {
-  return /* @__PURE__ */ jsxs4(Box3, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx4(Text4, { children: hardwareText(session) }),
-    /* @__PURE__ */ jsx4(Text4, { children: runtimesText(session) }),
-    /* @__PURE__ */ jsx4(Text4, { color: "yellow", children: t("hardwareHint") })
-  ] });
-}
-
-// src/tui/views/Recommend.tsx
-import { Box as Box4, Text as Text5 } from "ink";
-import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
-function RecommendView({ session }) {
-  const cols = useCols();
-  return /* @__PURE__ */ jsxs5(Box4, { flexDirection: "column", width: cols, children: [
-    /* @__PURE__ */ jsx5(Text5, { bold: true, color: "magenta", children: t("recommended") }),
-    /* @__PURE__ */ jsx5(Typewriter, { text: fit(t("aboutRecommend"), cols), ms: 12, dimColor: true }),
-    session.recommendations.map((rec) => /* @__PURE__ */ jsxs5(Text5, { children: [
-      /* @__PURE__ */ jsx5(Text5, { color: "magenta", children: fit(rec.useCase, 10) }),
-      /* @__PURE__ */ jsxs5(Text5, { children: [
-        " ",
-        fit(rec.model.name, 22),
-        " "
-      ] }),
-      /* @__PURE__ */ jsx5(Text5, { color: gradeColor(rec.grade), children: rec.grade }),
-      /* @__PURE__ */ jsxs5(Text5, { children: [
-        " ",
-        GRADE_MEANING[rec.grade]
-      ] }),
-      /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
-        " ",
-        resolveOllamaTag(rec.model.id, rec.model.name) ?? "\u2014"
-      ] })
-    ] }, `${rec.useCase}-${rec.model.id}`)),
-    /* @__PURE__ */ jsx5(Text5, { color: "yellow", children: fit(t("setupCta"), cols) })
-  ] });
-}
-
-// src/tui/views/Setup.tsx
-import { Box as Box5, Text as Text6, useApp, useInput } from "ink";
-import { useState as useState2 } from "react";
-
-// src/integrations/catalog.ts
-var INTEGRATIONS = {
-  opencode: {
-    id: "opencode",
-    docsUrl: "https://docs.ollama.com/integrations/opencode",
-    ollamaLaunch: "opencode",
-    minGenerationTps: 12,
-    allowedGrades: ["S", "A", "B"],
-    useCases: ["code", "chat", "reasoning"]
-  },
-  openclaw: {
-    id: "openclaw",
-    docsUrl: "https://docs.ollama.com/integrations/openclaw",
-    ollamaLaunch: "openclaw",
-    minGenerationTps: 12,
-    allowedGrades: ["S", "A", "B"],
-    useCases: ["code", "chat", "reasoning"]
-  },
-  hermes: {
-    id: "hermes",
-    docsUrl: "https://docs.ollama.com/integrations/hermes",
-    ollamaLaunch: "hermes",
-    minGenerationTps: 12,
-    allowedGrades: ["S", "A"],
-    useCases: ["code", "chat", "reasoning"]
-  },
-  claude: {
-    id: "claude",
-    docsUrl: "https://docs.ollama.com/integrations/claude-code",
-    ollamaLaunch: "claude",
-    minGenerationTps: 12,
-    allowedGrades: ["S", "A", "B"],
-    useCases: ["code", "chat", "reasoning"]
-  }
-};
-
-// src/integrations/types.ts
-var INTEGRATION_IDS = ["opencode", "openclaw", "hermes", "claude"];
-
-// src/integrations/decide.ts
-var GRADE_RANK = { S: 5, A: 4, B: 3, C: 2, D: 1, F: 0 };
-function useCaseOk(useCases, needed) {
-  if (!useCases?.length) return needed.includes("chat");
-  return useCases.some((u) => needed.some((n) => u.includes(n)));
-}
-function decideLaunch(session, id) {
-  const def = INTEGRATIONS[id];
-  const reasons = [];
-  const ollama = session.runtimes.find((r) => r.id === "ollama")?.detected;
-  if (!ollama) reasons.push(t("launchNeedOllama"));
-  const candidates = [];
-  for (const row of session.rows) {
-    const useCases = row.catalog?.useCase ?? ["chat", "code"];
-    if (!useCaseOk(useCases, def.useCases)) continue;
-    const tag = resolveOllamaTag(row.local.id, row.local.name, row.catalog?.id, row.catalog?.name);
-    if (!tag) continue;
-    const tps = row.lastBenchmark?.benchmark.generationTokensPerSecond;
-    candidates.push({
-      modelId: row.local.id,
-      ollamaTag: tag,
-      installed: true,
-      origin: row.lastBenchmark ? "measured" : "estimated",
-      grade: row.compatibility?.grade,
-      tps
-    });
-  }
-  if (!candidates.length) {
-    for (const model of session.catalog) {
-      if (!useCaseOk(model.useCase, def.useCases)) continue;
-      const fit2 = localCompatibility(session.hardware, model);
-      if (!def.allowedGrades.includes(fit2.grade)) continue;
-      const tag = resolveOllamaTag(model.id, model.name);
-      if (!tag) continue;
-      candidates.push({
-        modelId: model.id,
-        ollamaTag: tag,
-        installed: false,
-        origin: "estimated",
-        grade: fit2.grade
-      });
-    }
-  }
-  candidates.sort((a, b) => {
-    if (a.installed !== b.installed) return a.installed ? -1 : 1;
-    return (GRADE_RANK[b.grade ?? "F"] ?? 0) - (GRADE_RANK[a.grade ?? "F"] ?? 0);
-  });
-  const pick = candidates[0];
-  if (!pick) reasons.push(t("launchNoModel"));
-  if (pick?.grade && !def.allowedGrades.includes(pick.grade)) {
-    reasons.push(t("launchGradeFail", { grade: pick.grade, allowed: def.allowedGrades.join(",") }));
-  }
-  if (pick?.origin === "measured" && pick.tps !== void 0 && pick.tps < def.minGenerationTps) {
-    reasons.push(t("launchSlowFail", { tps: pick.tps.toFixed(1), min: def.minGenerationTps }));
-  }
-  if (pick && pick.origin === "estimated" && (!pick.grade || GRADE_RANK[pick.grade] < GRADE_RANK.B)) {
-    reasons.push(t("launchEstimateWeak"));
-  }
-  const eligible = Boolean(ollama && pick && reasons.length === 0);
-  const command = pick ? `ollama launch ${def.ollamaLaunch} --model ${pick.ollamaTag}` : `ollama launch ${def.ollamaLaunch}`;
-  return {
-    integration: id,
-    docsUrl: def.docsUrl,
-    eligible,
-    reasons: eligible ? [t("launchOk")] : reasons,
-    modelId: pick?.modelId,
-    ollamaTag: pick?.ollamaTag,
-    installed: pick?.installed ?? false,
-    origin: pick?.origin,
-    grade: pick?.grade,
-    command
-  };
-}
-function decideAll(session) {
-  return INTEGRATION_IDS.map((id) => decideLaunch(session, id));
-}
-function launchText(decisions) {
-  const lines = [t("launchTitle"), t("launchHint"), ""];
-  for (const d of decisions) {
-    lines.push(`${d.integration}  ${d.docsUrl}`);
-    lines.push(`  ${d.eligible ? "\u2713" : "\u25CB"} ${d.reasons.join(" ")}`);
-    if (d.modelId) {
-      lines.push(
-        `  ${t("launchModel")}: ${d.modelId}  ${d.grade ?? "\u2014"}  ${d.origin === "measured" ? t("measured") : t("estimated")}  ${d.installed ? t("tasksInstalled") : t("tasksNotInstalled")}`
-      );
-    }
-    lines.push(`  ${d.command}`);
-    if (d.eligible) lines.push(`  ${t("launchRunHint", { tool: d.integration })}`);
-    else lines.push(`  ${t("launchBlocked")}`);
-    lines.push("");
-  }
-  return lines.join("\n");
-}
-function parseIntegration(raw) {
-  if (!raw) return void 0;
-  const id = raw.toLowerCase();
-  if (id === "claude-code") return "claude";
-  return INTEGRATION_IDS.find((item) => item === id);
-}
-
-// src/integrations/execute.ts
-init_process();
-async function executeLaunch(decision) {
-  if (!decision.eligible || !decision.ollamaTag) {
-    return { ok: false, log: t("launchBlocked") };
-  }
-  const def = INTEGRATIONS[decision.integration];
-  if (!def) return { ok: false, log: t("launchUnknown") };
-  const lines = [];
-  if (!decision.installed) {
-    lines.push(t("launchPulling", { model: decision.ollamaTag }));
-    const pull = await runCommand("ollama", ["pull", decision.ollamaTag], { timeout: 30 * 6e4 });
-    if (pull.exitCode !== 0) {
-      return { ok: false, log: `${lines.join("\n")}
-${pull.stderr || t("launchPullFail")}` };
-    }
-  }
-  const args2 = ["launch", def.ollamaLaunch, "--model", decision.ollamaTag];
-  if (def.id === "openclaw" || def.id === "claude") args2.push("--yes");
-  lines.push(`ollama ${args2.join(" ")}`);
-  const launched = await runCommand("ollama", args2, { timeout: 12e4 });
-  if (launched.exitCode !== 0) {
-    return {
-      ok: false,
-      log: `${lines.join("\n")}
-${launched.stderr || launched.stdout || t("launchExecFail")}`
-    };
-  }
-  return { ok: true, log: `${lines.join("\n")}
-${launched.stdout}`.trim() };
-}
-async function installWithBrew(kind) {
-  const { brewInstall: brewInstall2 } = await Promise.resolve().then(() => (init_brew(), brew_exports));
-  if (kind === "ollama") {
-    const result = await brewInstall2(["install", "ollama"]);
-    if (result.ok) {
-      void runCommand("ollama", ["serve"], { timeout: 4e3 });
-    }
-    return result;
-  }
-  return brewInstall2(["install", "--cask", "lm-studio"]);
-}
-async function executeDockerOllama() {
-  const { brewInstallCask: brewInstallCask2, dockerReady: dockerReady2, startDockerDesktop: startDockerDesktop2, waitForDocker: waitForDocker2 } = await Promise.resolve().then(() => (init_brew(), brew_exports));
-  const notes = [];
-  if (!await dockerReady2()) {
-    notes.push(t("dockerBrewInstall"));
-    const installed2 = await brewInstallCask2("docker");
-    if (!installed2.ok) {
-      return { ok: false, log: `${t("reqDocker")}
-${installed2.log}` };
-    }
-    notes.push(t("dockerDesktopWait"));
-    await startDockerDesktop2();
-    const up = await waitForDocker2();
-    if (!up) return { ok: false, log: `${notes.join("\n")}
-${t("dockerRunFail")}` };
-  }
-  const start = await runCommand("docker", ["start", "pudu-ollama"], { timeout: 3e4 });
-  if (start.exitCode === 0) return { ok: true, log: t("dockerRunOk") };
-  const args2 = DOCKER_OLLAMA.split(" ").slice(1);
-  const result = await runCommand("docker", args2, { timeout: 10 * 6e4 });
-  if (result.exitCode !== 0) {
-    return { ok: false, log: result.stderr || t("dockerRunFail") };
-  }
-  return { ok: true, log: t("dockerRunOk") };
-}
-
-// src/integrations/pull.ts
-init_process();
-var INSTALLABLE = ["S", "A", "B"];
-function canInstallGrade(grade) {
-  return Boolean(grade && INSTALLABLE.includes(grade));
-}
-async function pullOllamaModel(modelId, extraName) {
-  const tag = resolveOllamaTag(modelId, extraName);
-  if (!tag) {
-    return { ok: false, log: t("noOllamaTag", { model: extraName ?? modelId }), tag: modelId };
-  }
-  const result = await runCommand("ollama", ["pull", tag], { timeout: 30 * 6e4 });
-  if (result.exitCode !== 0) {
-    return { ok: false, log: result.stderr || t("launchPullFail"), tag };
-  }
-  return { ok: true, log: t("modelPulled", { model: tag }), tag };
-}
-
-// src/tui/views/Setup.tsx
-import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
-var TOOLS = [
-  { key: "1", id: "opencode", label: "OpenCode" },
-  { key: "2", id: "hermes", label: "Hermes" },
-  { key: "3", id: "openclaw", label: "OpenClaw" }
-];
-function SetupView({ session }) {
-  const cols = useCols();
-  const { exit } = useApp();
-  const [cursor, setCursor] = useState2(0);
-  const [log, setLog] = useState2("");
-  const [busy, setBusy] = useState2(false);
-  const recs = session.recommendations;
-  const rec = recs[cursor];
-  useInput((input, key) => {
-    if (busy) return;
-    if (key.upArrow) setCursor((c) => Math.max(0, c - 1));
-    if (key.downArrow) setCursor((c) => Math.min(Math.max(recs.length - 1, 0), c + 1));
-    if ((input.toLowerCase() === "i" || key.return) && rec) {
-      if (!canInstallGrade(rec.grade)) {
-        setLog(t("installGradeBlock", { grade: rec.grade }));
-        return;
-      }
-      setBusy(true);
-      setLog(t("launchPulling", { model: rec.model.name }));
-      void pullOllamaModel(rec.model.id, rec.model.name).then((result) => {
-        setLog(result.log);
-        setBusy(false);
-      });
-    }
-    if (input === "4") {
-      setBusy(true);
-      setLog(t("dockerStarting"));
-      void executeDockerOllama().then((result) => {
-        setLog(result.log);
-        setBusy(false);
-      });
-      return;
-    }
-    if (input === "5") {
-      setBusy(true);
-      setLog(t("brewInstalling", { pkg: "ollama" }));
-      void installWithBrew("ollama").then((result) => {
-        setLog(result.log);
-        setBusy(false);
-      });
-      return;
-    }
-    if (input === "6") {
-      setBusy(true);
-      setLog(t("brewInstalling", { pkg: "lm-studio" }));
-      void installWithBrew("lmstudio").then((result) => {
-        setLog(result.log);
-        setBusy(false);
-      });
-      return;
-    }
-    const tool = TOOLS.find((item) => item.key === input)?.id;
-    if (tool) {
-      const ollama = session.runtimes.find((r) => r.id === "ollama")?.detected;
-      const agent = session.agents.find((a) => a.id === tool);
-      if (!ollama) {
-        setBusy(true);
-        setLog(t("brewInstalling", { pkg: "ollama" }));
-        void installWithBrew("ollama").then((brewed) => {
-          setLog(brewed.log);
-          setBusy(false);
-        });
-        return;
-      }
-      if (agent && !agent.detected) {
-        setBusy(true);
-        setLog(t("linkingTool", { tool, model: rec?.model.id ?? "" }));
-        const decision = decideLaunch(session, tool);
-        void executeLaunch(
-          decision.eligible ? decision : { ...decision, eligible: true, ollamaTag: decision.ollamaTag ?? "qwen3:8b", installed: false }
-        ).then((result) => {
-          setLog(result.log);
-          setBusy(false);
-        });
-        return;
-      }
-      if (rec) {
-        const decision = decideLaunch(session, tool);
-        if (!decision.eligible) {
-          setLog(decision.reasons.join(" "));
-          return;
-        }
-        setBusy(true);
-        setLog(t("linkingTool", { tool, model: rec.model.id }));
-        void executeLaunch(decision).then((result) => {
-          setLog(result.log);
-          setBusy(false);
-          if (result.ok) exit();
-        });
-      }
-    }
-  });
-  const tag = rec ? resolveOllamaTag(rec.model.id, rec.model.name) : void 0;
-  return /* @__PURE__ */ jsxs6(Box5, { flexDirection: "column", width: cols, children: [
-    /* @__PURE__ */ jsx6(Text6, { bold: true, color: "yellow", children: fit(t("setupTitle"), cols) }),
-    recs.map((item, i) => /* @__PURE__ */ jsxs6(Text6, { color: i === cursor ? "cyan" : void 0, children: [
-      i === cursor ? "\u276F " : "  ",
-      fit(item.model.name, 20),
-      " ",
-      /* @__PURE__ */ jsx6(Text6, { color: gradeColor(item.grade), children: item.grade }),
-      /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
-        " ",
-        resolveOllamaTag(item.model.id, item.model.name) ?? "\u2014"
-      ] })
-    ] }, `${item.useCase}-${item.model.id}`)),
-    session.agents.map((agent, index) => /* @__PURE__ */ jsxs6(Text6, { color: agent.detected ? "green" : "yellow", children: [
-      "[",
-      index + 1,
-      "] ",
-      agent.detected ? "\u2713" : "\u25CB",
-      " ",
-      agent.label,
-      agent.detected ? "" : `  \u2192 ${agent.launch}`
-    ] }, agent.id)),
-    /* @__PURE__ */ jsxs6(Text6, { color: session.runtimes.find((r) => r.id === "docker")?.detected ? "green" : "yellow", children: [
-      "[4] ",
-      session.runtimes.find((r) => r.id === "docker")?.detected ? "\u2713" : "\u25CB",
-      " Docker",
-      session.runtimes.find((r) => r.id === "docker")?.detected ? `  \u2192 ${t("dockerHint")}` : `  \u2192 ${t("reqDocker")}`
-    ] }),
-    /* @__PURE__ */ jsxs6(Text6, { color: session.runtimes.find((r) => r.id === "ollama")?.detected ? "green" : "yellow", children: [
-      "[5] ",
-      session.runtimes.find((r) => r.id === "ollama")?.detected ? "\u2713" : "\u25CB",
-      " Ollama",
-      session.runtimes.find((r) => r.id === "ollama")?.detected ? "" : "  \u2192 brew install ollama"
-    ] }),
-    /* @__PURE__ */ jsxs6(Text6, { color: session.runtimes.find((r) => r.id === "lmstudio")?.detected ? "green" : "yellow", children: [
-      "[6] ",
-      session.runtimes.find((r) => r.id === "lmstudio")?.detected ? "\u2713" : "\u25CB",
-      " LM Studio",
-      session.runtimes.find((r) => r.id === "lmstudio")?.detected ? "" : "  \u2192 brew install --cask lm-studio"
-    ] }),
-    /* @__PURE__ */ jsx6(Typewriter, { text: fit(`Enter=pull ${tag ?? ""}  1-3 agent  4 docker  5 ollama  6 LM Studio`, cols), ms: 14, dimColor: true }),
-    log ? /* @__PURE__ */ jsx6(Text6, { color: "green", children: fit(log, cols) }) : null
-  ] });
-}
-
-// src/tui/views/Compare.tsx
-import { Box as Box6, Text as Text7 } from "ink";
-import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
-function CompareView({ session }) {
-  const cols = useCols();
-  const n = new Set(session.history.map((h) => h.model.id)).size;
-  return /* @__PURE__ */ jsxs7(Box6, { flexDirection: "column", width: cols, children: [
-    /* @__PURE__ */ jsx7(Text7, { bold: true, color: "green", children: t("compareTitle") }),
-    /* @__PURE__ */ jsx7(Typewriter, { text: fit(t("compareHow"), cols), ms: 12, dimColor: true }),
-    n < 2 ? /* @__PURE__ */ jsx7(Text7, { color: "yellow", children: fit(t("compareNeedBench"), cols) }) : /* @__PURE__ */ jsx7(Text7, { children: compareText(session.history) })
-  ] });
-}
-
-// src/tui/views/Benchmark.tsx
-import { Box as Box7, Text as Text8, useInput as useInput2 } from "ink";
-import { useEffect as useEffect2, useRef, useState as useState3 } from "react";
-import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
-function BenchmarkView(props) {
-  const [phase, setPhase] = useState3(props.models.length ? "select" : "error");
-  const [sample, setSample] = useState3();
-  const [elapsed, setElapsed] = useState3(0);
-  const [result, setResult] = useState3();
-  const [error, setError] = useState3(props.models.length ? "" : t("noGguf"));
-  const cpuHist = useRef([]);
-  const memHist = useRef([]);
-  const abortRef = useRef(void 0);
-  useInput2((input, key) => {
-    if (phase === "select") {
-      if (key.upArrow) props.setSelected(Math.max(0, props.selected - 1));
-      if (key.downArrow) props.setSelected(Math.min(props.models.length - 1, props.selected + 1));
-      if (key.return && props.models[props.selected]) setPhase("running");
-      if (input.toLowerCase() === "q" || key.escape) props.onBack();
-    } else if (phase === "running" && (input.toLowerCase() === "q" || key.escape)) {
-      abortRef.current?.abort();
-    } else if ((phase === "done" || phase === "error") && (input.toLowerCase() === "q" || key.escape || key.return)) {
-      props.onBack();
-    }
-  });
-  useEffect2(() => {
-    if (phase !== "running") return;
-    const model2 = props.models[props.selected];
-    if (!model2) return;
-    const controller = new AbortController();
-    abortRef.current = controller;
-    void (async () => {
-      try {
-        const catalog = props.session.rows.find((r) => r.local.id === model2.id)?.catalog;
-        const out = await runBenchmark({
-          model: model2,
-          hardware: props.session.hardware,
-          preset: props.preset,
-          catalog,
-          signal: controller.signal,
-          onProgress: (p) => {
-            setElapsed(p.elapsedSeconds);
-            if (p.sample) {
-              setSample(p.sample);
-              if (p.sample.cpu?.utilizationPercent !== void 0) {
-                cpuHist.current = [...cpuHist.current, p.sample.cpu.utilizationPercent].slice(-32);
-              }
-              memHist.current = [...memHist.current, p.sample.memory.usedBytes].slice(-32);
-            }
-          }
-        });
-        setResult(out);
-        setPhase("done");
-      } catch (err) {
-        setError(err instanceof Error ? err.message : String(err));
-        setPhase("error");
-      }
-    })();
-    return () => controller.abort();
-  }, [phase, props.models, props.preset, props.selected, props.session]);
-  const h = props.session.hardware;
-  const model = props.models[props.selected];
-  if (phase === "select") {
-    return /* @__PURE__ */ jsxs8(Box7, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsx8(Text8, { bold: true, children: t("selectBenchmark") }),
-      props.models.map((m, i) => /* @__PURE__ */ jsxs8(Text8, { color: i === props.selected ? "cyan" : void 0, children: [
-        i === props.selected ? "\u276F " : "  ",
-        m.name
-      ] }, m.id)),
-      /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: t("enterToRun") })
-    ] });
-  }
-  if (phase === "done" && result) {
-    return /* @__PURE__ */ jsxs8(Box7, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsx8(Text8, { children: resultText(result.record, result.assessment) }),
-      /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
-        t("saved"),
-        " ",
-        result.path
-      ] })
-    ] });
-  }
-  if (phase === "error") {
-    return /* @__PURE__ */ jsx8(Box7, { flexDirection: "column", children: /* @__PURE__ */ jsx8(Text8, { color: "red", children: error }) });
-  }
-  const cpu = sample?.cpu?.utilizationPercent;
-  const gpu = sample?.gpu?.utilizationPercent;
-  const memUsed = sample?.memory.usedBytes;
-  const memTotal = h.memory.totalBytes;
-  return /* @__PURE__ */ jsxs8(Box7, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsxs8(Box7, { borderStyle: "round", borderColor: "cyan", flexDirection: "column", paddingX: 1, children: [
-      /* @__PURE__ */ jsx8(Text8, { bold: true, children: t("benchmarkTitle") }),
-      /* @__PURE__ */ jsx8(Text8, { children: model?.name }),
-      /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
-        h.cpu.name,
-        " \xB7 ",
-        formatBytes(h.memory.totalBytes, 0),
-        " ",
-        memoryLabel(h)
-      ] })
-    ] }),
-    /* @__PURE__ */ jsxs8(Box7, { marginTop: 1, flexDirection: "column", children: [
-      /* @__PURE__ */ jsx8(Text8, { bold: true, color: "cyan", children: t("performance") }),
-      /* @__PURE__ */ jsxs8(Text8, { children: [
-        t("elapsed"),
-        "                    ",
-        elapsed.toFixed(1),
-        " s"
-      ] }),
-      /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: t("measuredAfter") })
-    ] }),
-    /* @__PURE__ */ jsxs8(Box7, { marginTop: 1, flexDirection: "column", children: [
-      /* @__PURE__ */ jsx8(Text8, { bold: true, color: "cyan", children: t("system") }),
-      /* @__PURE__ */ jsxs8(Text8, { children: [
-        "CPU       ",
-        bar(cpu),
-        "       ",
-        formatPercent(cpu)
-      ] }),
-      /* @__PURE__ */ jsxs8(Text8, { children: [
-        "GPU       ",
-        bar(gpu),
-        "       ",
-        formatPercent(gpu)
-      ] }),
-      /* @__PURE__ */ jsxs8(Text8, { children: [
-        "Memory    ",
-        bar(memUsed && memTotal ? memUsed / memTotal * 100 : void 0),
-        "      ",
-        memUsed ? formatBytes(memUsed) : "N/A",
-        " / ",
-        formatBytes(memTotal, 0)
-      ] }),
-      /* @__PURE__ */ jsxs8(Text8, { children: [
-        "Swap      ",
-        bar(0),
-        "      ",
-        sample ? formatBytes(sample.memory.swapUsedBytes) : "N/A"
-      ] })
-    ] }),
-    /* @__PURE__ */ jsxs8(Box7, { marginTop: 1, flexDirection: "column", children: [
-      /* @__PURE__ */ jsx8(Text8, { bold: true, color: "cyan", children: t("powerThermals") }),
-      /* @__PURE__ */ jsxs8(Text8, { children: [
-        "Package                    ",
-        sample?.packagePowerWatts ?? "N/A",
-        " W"
-      ] }),
-      /* @__PURE__ */ jsxs8(Text8, { children: [
-        "Temperature                ",
-        sample?.thermal?.temperatureC ?? "N/A",
-        " \xB0C"
-      ] }),
-      /* @__PURE__ */ jsxs8(Text8, { children: [
-        "Thermal Pressure           ",
-        sample?.thermal?.pressure ?? "N/A"
-      ] }),
-      /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: t("permissionsHint") })
-    ] }),
-    /* @__PURE__ */ jsxs8(Text8, { children: [
-      sparkline(cpuHist.current),
-      " CPU"
-    ] }),
-    /* @__PURE__ */ jsxs8(Text8, { children: [
-      sparkline(memHist.current.map((v) => v / 1024 ** 3)),
-      " Memory"
-    ] }),
-    /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: t("cancelHint") })
-  ] });
-}
-
-// src/tui/views/History.tsx
-import { Box as Box8, Text as Text9 } from "ink";
-import { jsx as jsx9, jsxs as jsxs9 } from "react/jsx-runtime";
-function HistoryView({ session }) {
-  return /* @__PURE__ */ jsxs9(Box8, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx9(Text9, { bold: true, color: "cyan", children: t("measured") }),
-    /* @__PURE__ */ jsx9(Text9, { children: historyText(session.history) })
-  ] });
-}
-
-// src/tui/views/Tasks.tsx
-import { Box as Box9, Text as Text10, useInput as useInput3 } from "ink";
-import { useMemo, useState as useState4 } from "react";
-
-// src/tasks/catalog.ts
-var TASK_CATALOG = [
-  {
-    id: "code-review",
-    kind: "code",
-    useCases: ["code"],
-    titleKey: "taskCodeReviewTitle",
-    promptKey: "taskCodeReviewPrompt",
-    harnessId: "H-CODE-REVIEW"
-  },
-  {
-    id: "code-tests",
-    kind: "code",
-    useCases: ["code"],
-    titleKey: "taskCodeTestsTitle",
-    promptKey: "taskCodeTestsPrompt",
-    harnessId: "H-CODE-TESTS"
-  },
-  {
-    id: "chat-plan",
-    kind: "chat",
-    useCases: ["chat"],
-    titleKey: "taskChatPlanTitle",
-    promptKey: "taskChatPlanPrompt",
-    harnessId: "H-CHAT-PLAN"
-  },
-  {
-    id: "chat-agent",
-    kind: "chat",
-    useCases: ["chat", "code"],
-    titleKey: "taskChatAgentTitle",
-    promptKey: "taskChatAgentPrompt",
-    harnessId: "H-CHAT-AGENT"
-  },
-  {
-    id: "image-caption",
-    kind: "image",
-    useCases: ["image", "vision"],
-    titleKey: "taskImageCaptionTitle",
-    promptKey: "taskImageCaptionPrompt",
-    harnessId: "H-IMAGE-CAPTION"
-  },
-  {
-    id: "image-edit-brief",
-    kind: "image",
-    useCases: ["image", "vision"],
-    titleKey: "taskImageBriefTitle",
-    promptKey: "taskImageBriefPrompt",
-    harnessId: "H-IMAGE-BRIEF"
-  },
-  {
-    id: "video-storyboard",
-    kind: "video",
-    useCases: ["video"],
-    titleKey: "taskVideoBoardTitle",
-    promptKey: "taskVideoBoardPrompt",
-    harnessId: "H-VIDEO-BOARD"
-  },
-  {
-    id: "video-shotlist",
-    kind: "video",
-    useCases: ["video"],
-    titleKey: "taskVideoShotTitle",
-    promptKey: "taskVideoShotPrompt",
-    harnessId: "H-VIDEO-SHOTS"
-  },
-  {
-    id: "transcribe-clean",
-    kind: "transcription",
-    useCases: ["chat", "multilingual"],
-    titleKey: "taskTranscribeCleanTitle",
-    promptKey: "taskTranscribeCleanPrompt",
-    harnessId: "H-ASR-CLEAN"
-  },
-  {
-    id: "transcribe-actions",
-    kind: "transcription",
-    useCases: ["chat", "code"],
-    titleKey: "taskTranscribeActionsTitle",
-    promptKey: "taskTranscribeActionsPrompt",
-    harnessId: "H-ASR-ACTIONS"
-  }
-];
-
-// src/tasks/types.ts
-var WORK_KINDS = ["code", "video", "image", "transcription", "chat"];
-
-// src/tasks/plan.ts
-function parseKinds(raw) {
-  if (!raw) return [...WORK_KINDS];
-  const parts = raw.split(",").map((p) => p.trim().toLowerCase());
-  const kinds = WORK_KINDS.filter((k) => parts.includes(k));
-  return kinds.length ? kinds : [...WORK_KINDS];
-}
-function parseAnswers(input) {
-  return {
-    kinds: parseKinds(input.for),
-    scope: input.scope === "all" ? "all" : "installed",
-    priority: input.priority === "quality" || input.priority === "speed" ? input.priority : "balanced"
-  };
-}
-function kindMatches(kind, useCases) {
-  if (kind === "code") return useCases.some((u) => u.includes("code"));
-  if (kind === "image") return useCases.some((u) => u.includes("image") || u.includes("vision"));
-  if (kind === "video") return useCases.some((u) => u.includes("video"));
-  if (kind === "transcription") return useCases.some((u) => u.includes("chat") || u.includes("multilingual"));
-  return useCases.some((u) => u.includes("chat") || u.includes("reasoning") || u.includes("code"));
-}
-function planTasks(session, answers) {
-  const wanted = new Set(answers.kinds);
-  const defs = TASK_CATALOG.filter((task) => wanted.has(task.kind));
-  const plans = [];
-  const installed2 = session.rows.map((row) => {
-    const useCases = row.catalog?.useCase ?? ["chat", "code"];
-    const kinds = answers.kinds.filter((kind) => kindMatches(kind, useCases));
-    return {
-      modelId: row.local.id,
-      modelName: row.local.name,
-      installed: true,
-      origin: row.lastBenchmark ? "measured" : "estimated",
-      grade: row.compatibility?.grade,
-      useCases,
-      kinds
-    };
-  });
-  const catalogExtras = answers.scope === "all" ? session.catalog.filter((model) => !session.rows.some((row) => idsLikelyMatch(row.local.id, model.id))).map((model) => {
-    const useCases = model.useCase ?? [];
-    const kinds = answers.kinds.filter((kind) => kindMatches(kind, useCases));
-    const fit2 = localCompatibility(session.hardware, model);
-    return {
-      modelId: model.id,
-      modelName: model.name,
-      installed: false,
-      origin: "estimated",
-      grade: fit2.grade,
-      useCases,
-      kinds
-    };
-  }).filter((row) => row.kinds.length && row.grade !== "F") : [];
-  const ranked = [...installed2, ...catalogExtras].filter((row) => row.kinds.length);
-  ranked.sort((a, b) => {
-    if (a.installed !== b.installed) return a.installed ? -1 : 1;
-    if (answers.priority === "speed") return (a.grade ?? "C").localeCompare(b.grade ?? "C");
-    if (answers.priority === "quality") return (b.grade ?? "C").localeCompare(a.grade ?? "C");
-    return 0;
-  });
-  for (const row of ranked.slice(0, 8)) {
-    const tasks = defs.filter((def) => row.kinds.includes(def.kind) && def.useCases.some((u) => row.useCases.includes(u) || kindMatches(def.kind, row.useCases))).slice(0, 3).map((def) => ({
-      id: def.id,
-      harnessId: def.harnessId,
-      kind: def.kind,
-      title: t(def.titleKey),
-      prompt: t(def.promptKey)
-    }));
-    if (!tasks.length) continue;
-    plans.push({
-      modelId: row.modelId,
-      modelName: row.modelName,
-      installed: row.installed,
-      origin: row.origin,
-      grade: row.grade,
-      kinds: row.kinds,
-      tasks
-    });
-  }
-  return plans;
-}
-function tasksText(plans, answers) {
-  const header = [
-    t("tasksTitle"),
-    t("tasksHint"),
-    `${t("tasksKinds")}: ${answers.kinds.join(", ")}`,
-    `${t("tasksScope")}: ${answers.scope}`,
-    `${t("tasksPriority")}: ${answers.priority}`,
-    t("credits"),
-    ""
-  ];
-  if (!plans.length) return [...header, t("tasksEmpty")].join("\n");
-  const blocks = plans.map((plan) => {
-    const inst = plan.installed ? t("tasksInstalled") : t("tasksNotInstalled");
-    const origin = plan.origin === "measured" ? t("measured") : t("estimated");
-    const lines = [
-      `${plan.modelName}  [${inst}]  ${plan.grade ?? "\u2014"}  ${origin}`,
-      `  ${plan.kinds.join(", ")}`,
-      ...plan.tasks.map((task) => `  ${task.harnessId}  ${task.title}
-      ${task.prompt}`)
-    ];
-    return lines.join("\n");
-  });
-  return [...header, ...blocks].join("\n\n");
-}
-
-// src/tui/views/Tasks.tsx
-import { Fragment, jsx as jsx10, jsxs as jsxs10 } from "react/jsx-runtime";
-var KIND_LABEL = {
-  code: "tasksOptCode",
-  video: "tasksOptVideo",
-  image: "tasksOptImage",
-  transcription: "tasksOptTranscription",
-  chat: "tasksOptChat"
-};
-function TasksView({ session }) {
-  const [step, setStep] = useState4(0);
-  const [cursor, setCursor] = useState4(0);
-  const [kinds, setKinds] = useState4(["code", "chat"]);
-  const [scope, setScope] = useState4("installed");
-  const [priority, setPriority] = useState4("balanced");
-  const plans = useMemo(
-    () => planTasks(session, { kinds, scope, priority }),
-    [session, kinds, scope, priority]
-  );
-  useInput3((input, key) => {
-    if (step === 0) {
-      if (key.upArrow) setCursor((c) => Math.max(0, c - 1));
-      if (key.downArrow) setCursor((c) => Math.min(WORK_KINDS.length - 1, c + 1));
-      if (input === " " || input === "x") {
-        const kind = WORK_KINDS[cursor];
-        if (!kind) return;
-        setKinds(
-          (current2) => current2.includes(kind) ? current2.filter((k) => k !== kind) : [...current2, kind]
-        );
-      }
-      if (key.return && kinds.length) setStep(1);
-    } else if (step === 1) {
-      if (key.upArrow || key.downArrow) setScope((s) => s === "installed" ? "all" : "installed");
-      if (key.return) setStep(2);
-    } else if (step === 2) {
-      const order = ["speed", "balanced", "quality"];
-      if (key.upArrow) setPriority(order[Math.max(0, order.indexOf(priority) - 1)] ?? "speed");
-      if (key.downArrow) setPriority(order[Math.min(2, order.indexOf(priority) + 1)] ?? "quality");
-      if (key.return) setStep(3);
-    }
-  });
-  if (step === 3) {
-    return /* @__PURE__ */ jsx10(Box9, { flexDirection: "column", children: /* @__PURE__ */ jsx10(Text10, { children: tasksText(plans, { kinds, scope, priority }) }) });
-  }
-  return /* @__PURE__ */ jsxs10(Box9, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx10(Text10, { bold: true, color: "cyan", children: t("tasksTitle") }),
-    step === 0 && /* @__PURE__ */ jsxs10(Fragment, { children: [
-      /* @__PURE__ */ jsx10(Text10, { children: t("tasksQ1") }),
-      WORK_KINDS.map((kind, i) => /* @__PURE__ */ jsxs10(Text10, { color: i === cursor ? "cyan" : void 0, children: [
-        i === cursor ? "\u276F " : "  ",
-        "[",
-        kinds.includes(kind) ? "x" : " ",
-        "] ",
-        t(KIND_LABEL[kind])
-      ] }, kind))
-    ] }),
-    step === 1 && /* @__PURE__ */ jsxs10(Fragment, { children: [
-      /* @__PURE__ */ jsx10(Text10, { children: t("tasksQ2") }),
-      /* @__PURE__ */ jsxs10(Text10, { color: scope === "installed" ? "cyan" : void 0, children: [
-        scope === "installed" ? "\u276F " : "  ",
-        t("tasksOptInstalled")
-      ] }),
-      /* @__PURE__ */ jsxs10(Text10, { color: scope === "all" ? "cyan" : void 0, children: [
-        scope === "all" ? "\u276F " : "  ",
-        t("tasksOptAll")
-      ] })
-    ] }),
-    step === 2 && /* @__PURE__ */ jsxs10(Fragment, { children: [
-      /* @__PURE__ */ jsx10(Text10, { children: t("tasksQ3") }),
-      ["speed", "balanced", "quality"].map((item) => /* @__PURE__ */ jsxs10(Text10, { color: priority === item ? "cyan" : void 0, children: [
-        priority === item ? "\u276F " : "  ",
-        item === "speed" ? t("tasksOptSpeed") : item === "quality" ? t("tasksOptQuality") : t("tasksOptBalanced")
-      ] }, item))
-    ] })
-  ] });
-}
-
-// src/tui/keys.ts
-function globalNav(letter) {
-  if (letter === "b") return { type: "screen", screen: "benchmark" };
-  if (letter === "m") return { type: "screen", screen: "models" };
-  if (letter === "r") return { type: "screen", screen: "recommend" };
-  if (letter === "h") return { type: "screen", screen: "hardware" };
-  if (letter === "c") return { type: "screen", screen: "compare" };
-  if (letter === "l") return { type: "screen", screen: "history" };
-  if (letter === "t") return { type: "screen", screen: "tasks" };
-  if (letter === "s") return { type: "screen", screen: "setup" };
-  return void 0;
-}
-function handleAppKey(screen, input, key) {
-  const letter = input.toLowerCase();
-  if (screen === "benchmark") return { type: "ignore" };
-  if (letter === "q") return { type: "quit" };
-  if (key.escape) return screen === "home" ? { type: "quit" } : { type: "home" };
-  if (screen === "setup") {
-    if ("i123456".includes(letter)) return { type: "ignore" };
-  }
-  const nav = globalNav(letter);
-  if (nav) return nav;
-  if (letter === "i" && screen === "home") return { type: "screen", screen: "setup" };
-  if (key.return && screen === "home") return { type: "screen", screen: "benchmark" };
-  return { type: "ignore" };
-}
-
-// src/tui/Welcome.tsx
-import { Box as Box10, Text as Text11 } from "ink";
-import { Fragment as Fragment2, jsx as jsx11, jsxs as jsxs11 } from "react/jsx-runtime";
-function Chrome() {
-  const cols = useCols();
-  const wide = cols >= 72;
-  const brand = `${t("appTitle")}  ${t("byline")}`;
-  return /* @__PURE__ */ jsxs11(Box10, { flexDirection: "column", width: cols, marginBottom: 1, children: [
-    /* @__PURE__ */ jsx11(Typewriter, { text: brand, ms: 28, color: "cyan", bold: true, once: true }),
-    /* @__PURE__ */ jsx11(Text11, { children: wide ? /* @__PURE__ */ jsxs11(Fragment2, { children: [
-      /* @__PURE__ */ jsx11(Text11, { color: "yellow", children: "[S] Setup" }),
-      /* @__PURE__ */ jsx11(Text11, { children: "  " }),
-      /* @__PURE__ */ jsx11(Text11, { color: "green", children: "[B] Bench" }),
-      /* @__PURE__ */ jsx11(Text11, { children: "  " }),
-      /* @__PURE__ */ jsx11(Text11, { color: "cyan", children: "[M] Models" }),
-      /* @__PURE__ */ jsx11(Text11, { children: "  " }),
-      /* @__PURE__ */ jsx11(Text11, { color: "magenta", children: "[R] Rec" }),
-      /* @__PURE__ */ jsx11(Text11, { children: "  " }),
-      /* @__PURE__ */ jsx11(Text11, { color: "blue", children: "[T] Tasks" }),
-      /* @__PURE__ */ jsx11(Text11, { children: "  " }),
-      /* @__PURE__ */ jsx11(Text11, { children: "[H] HW" }),
-      /* @__PURE__ */ jsx11(Text11, { children: "  " }),
-      /* @__PURE__ */ jsx11(Text11, { color: "green", children: "[C] Cmp" }),
-      /* @__PURE__ */ jsx11(Text11, { children: "  " }),
-      /* @__PURE__ */ jsx11(Text11, { color: "cyan", children: "[L] Log" }),
-      /* @__PURE__ */ jsx11(Text11, { children: "  " }),
-      /* @__PURE__ */ jsx11(Text11, { color: "red", children: "[Q] Quit" })
-    ] }) : /* @__PURE__ */ jsxs11(Fragment2, { children: [
-      /* @__PURE__ */ jsx11(Text11, { color: "yellow", children: "[S]" }),
-      /* @__PURE__ */ jsx11(Text11, { color: "green", children: "[B]" }),
-      /* @__PURE__ */ jsx11(Text11, { color: "cyan", children: "[M]" }),
-      /* @__PURE__ */ jsx11(Text11, { color: "magenta", children: "[R]" }),
-      /* @__PURE__ */ jsx11(Text11, { color: "blue", children: "[T]" }),
-      /* @__PURE__ */ jsx11(Text11, { children: "[H]" }),
-      /* @__PURE__ */ jsx11(Text11, { color: "green", children: "[C]" }),
-      /* @__PURE__ */ jsx11(Text11, { color: "cyan", children: "[L]" }),
-      /* @__PURE__ */ jsx11(Text11, { color: "red", children: "[Q]" })
-    ] }) })
-  ] });
-}
-
-// src/tui/App.tsx
-import { jsx as jsx12, jsxs as jsxs12 } from "react/jsx-runtime";
-function App(props) {
-  const { exit } = useApp2();
-  const [screen, setScreen] = useState5(props.start ?? "home");
-  const screenRef = useRef2(screen);
-  screenRef.current = screen;
-  const [selected, setSelected] = useState5(0);
-  const benchable = useMemo2(
-    () => props.session.models.filter((m) => Boolean(m.artifactPath)),
-    [props.session.models]
-  );
-  useInput4((input, key) => {
-    const result = handleAppKey(screenRef.current, input, key);
-    if (result.type === "quit") exit();
-    if (result.type === "home") setScreen("home");
-    if (result.type === "screen") setScreen(result.screen);
-  });
-  return /* @__PURE__ */ jsxs12(Box11, { flexDirection: "column", paddingX: 1, children: [
-    screen !== "benchmark" && /* @__PURE__ */ jsx12(Chrome, {}),
-    screen === "home" && /* @__PURE__ */ jsx12(Dashboard, { session: props.session }),
-    screen === "models" && /* @__PURE__ */ jsx12(ModelsView, { session: props.session }),
-    screen === "hardware" && /* @__PURE__ */ jsx12(HardwareView, { session: props.session }),
-    screen === "recommend" && /* @__PURE__ */ jsx12(RecommendView, { session: props.session }),
-    screen === "setup" && /* @__PURE__ */ jsx12(SetupView, { session: props.session }),
-    screen === "compare" && /* @__PURE__ */ jsx12(CompareView, { session: props.session }),
-    screen === "history" && /* @__PURE__ */ jsx12(HistoryView, { session: props.session }),
-    screen === "tasks" && /* @__PURE__ */ jsx12(TasksView, { session: props.session }),
-    screen === "benchmark" && /* @__PURE__ */ jsx12(
-      BenchmarkView,
-      {
-        session: props.session,
-        models: benchable,
-        selected,
-        setSelected,
-        preset: props.preset,
-        onBack: () => setScreen("home")
-      }
-    )
-  ] });
-}
-
-// src/tui/render.tsx
-import { jsx as jsx13 } from "react/jsx-runtime";
-async function renderDashboard(session, preset, start) {
-  const instance = render(/* @__PURE__ */ jsx13(App, { session, preset, start }));
-  await instance.waitUntilExit();
-}
+// src/shared/logger.ts
+var level = "info";
+function setLogLevel(next) {
+  level = next;
+}
 
 // src/cli/help.ts
 function helpText() {
@@ -3540,6 +716,19 @@ function explained(aboutKey, body) {
 
 ${body}`;
 }
+async function openLab(session, preset, start) {
+  if (!process.stdout.isTTY || !process.stdin.isTTY) {
+    process.stdout.write(
+      `${explained("aboutDashboard", `${hardwareText(session)}
+
+${modelsText(session)}`)}
+`
+    );
+    return;
+  }
+  const { renderDashboard } = await import("./render-3UBPZNF4.js");
+  await renderDashboard(session, preset, start);
+}
 async function run(args2) {
   setLocale(resolveLocale(args2.lang));
   if (args2.help) {
@@ -3549,6 +738,10 @@ async function run(args2) {
   }
   if (args2.verbose) setLogLevel("verbose");
   if (!args2.color) process.env.NO_COLOR = "1";
+  if (args2.command === "repo") {
+    const { runRepoCommand } = await import("./repo-cli-4GSG5MD3.js");
+    return runRepoCommand(args2);
+  }
   const cleanup = () => {
     void killAll("SIGTERM");
   };
@@ -3565,7 +758,10 @@ async function run(args2) {
     process.stderr.write(`${t("loading")}
 `);
   }
-  const session = await loadSession({ network: args2.network });
+  const session = await loadSession({
+    network: args2.network,
+    light: args2.command === "launch" || args2.command === "doctor" || args2.command === "hardware"
+  });
   switch (args2.command) {
     case "hardware":
       print(
@@ -3583,7 +779,7 @@ ${runtimesText(session)}`),
         print({ recommendations: session.recommendations, agents: session.agents }, true);
         return 0;
       }
-      await renderDashboard(session, args2.preset, "setup");
+      await openLab(session, args2.preset, "setup");
       return 0;
     case "recommend": {
       if (args2.install && args2.yes) {
@@ -3680,7 +876,7 @@ ${runtimesText(session)}`),
           print({ error: t("jsonNeedModel") }, true);
           return 1;
         }
-        await renderDashboard(session, args2.preset);
+        await openLab(session, args2.preset);
         return 0;
       }
       const model = session.models.find((m) => m.id === id || m.name === id);
@@ -3690,6 +886,10 @@ ${runtimesText(session)}`),
         return 1;
       }
       const catalog = session.rows.find((r) => r.local.id === model.id)?.catalog;
+      if (!model.artifactPath && model.source === "ollama") {
+        const artifact = await ollamaAdapter.resolveModel(model.id);
+        model.artifactPath = artifact?.path;
+      }
       const result = await runBenchmark({
         model,
         hardware: session.hardware,
@@ -3710,7 +910,7 @@ ${runtimesText(session)}`),
         print(session, true);
         return 0;
       }
-      await renderDashboard(session, args2.preset);
+      await openLab(session, args2.preset);
       return 0;
   }
 }