pudu-ai 0.2.2

package/dist/cli/index.js

@@ -0,0 +1,3068 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+
+// src/cli/parse-args.ts
+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 command = rest[0] ?? "dashboard";
+  const known = [
+    "dashboard",
+    "hardware",
+    "models",
+    "recommend",
+    "benchmark",
+    "compare",
+    "history",
+    "doctor",
+    "report",
+    "tasks",
+    "launch"
+  ];
+  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");
+  return {
+    command: isKnown ? command : "dashboard",
+    positional: isKnown ? rest.slice(1) : rest,
+    json: flags.has("--json"),
+    csv: flags.has("--csv"),
+    network: !flags.has("--no-network"),
+    color: !flags.has("--no-color"),
+    verbose: flags.has("--verbose"),
+    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,
+    yes: flags.has("--yes")
+  };
+}
+
+// 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
+import os2 from "node:os";
+
+// src/shared/process.ts
+import { execa } from "execa";
+var children = /* @__PURE__ */ new Set();
+var installed = false;
+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);
+  }
+}
+
+// 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
+    }
+  };
+}
+
+// src/models/discovery.ts
+import os7 from "node:os";
+import path5 from "node:path";
+
+// 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;
+}
+
+// src/adapters/ollama/parse.ts
+function parseOllamaList(output) {
+  const lines = output.split(/\r?\n/).map((l) => l.trimEnd()).filter(Boolean);
+  if (lines.length === 0) return [];
+  const header = lines[0] ?? "";
+  if (!/^NAME\s+/i.test(header)) {
+    return lines.flatMap((line) => parseDataLine(line));
+  }
+  return lines.slice(1).flatMap((line) => parseDataLine(line));
+}
+function parseDataLine(line) {
+  const parts = line.trim().split(/\s{2,}/);
+  if (parts.length < 2) return [];
+  const name = parts[0];
+  if (!name || /^NAME$/i.test(name)) return [];
+  const digest = parts[1];
+  const sizeRaw = parts[2];
+  const modified = parts.slice(3).join(" ") || void 0;
+  return [
+    {
+      id: name,
+      name,
+      source: "ollama",
+      digest,
+      sizeBytes: sizeRaw ? parseSizeToBytes(sizeRaw.replace(/([A-Z]+)$/i, " $1")) : void 0,
+      modifiedAt: modified
+    }
+  ];
+}
+function parseOllamaModelfile(modelfile) {
+  const match = modelfile.match(/^FROM\s+(.+)$/m);
+  return { from: match?.[1]?.trim() };
+}
+
+// src/adapters/ollama/index.ts
+var ollamaAdapter = {
+  id: "ollama",
+  label: "Ollama",
+  async detect() {
+    return Boolean(await commandExists("ollama"));
+  },
+  async version() {
+    const result = await runCommand("ollama", ["--version"], { timeout: 8e3 });
+    const text = `${result.stdout} ${result.stderr}`;
+    const match = text.match(/(\d+\.\d+\.\d+)/);
+    return match?.[1];
+  },
+  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;
+  },
+  async resolveModel(id) {
+    return resolveOllamaBlob(id);
+  },
+  async benchmarkCapabilities() {
+    return ["llama-bench"];
+  }
+};
+async function resolveOllamaBlob(id) {
+  const result = await runCommand("ollama", ["show", "--modelfile", id], { timeout: 15e3 });
+  if (result.exitCode !== 0) return void 0;
+  const { from } = parseOllamaModelfile(result.stdout);
+  if (!from) return void 0;
+  const format = from.endsWith(".gguf") || from.includes("sha256-") ? "gguf" : "unknown";
+  return { id, path: from, format };
+}
+
+// src/adapters/lmstudio/index.ts
+import os6 from "node:os";
+import path4 from "node:path";
+import { access as access2 } from "node:fs/promises";
+
+// src/adapters/llamacpp/index.ts
+import { readdir, stat } from "node:fs/promises";
+import path3 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))]));
+  return Object.fromEntries(entries);
+}
+async function scanGgufDirectories(directories, options = {}) {
+  const maxDepth = options.maxDepth ?? 1;
+  const source = options.source ?? "gguf";
+  const models = [];
+  for (const dir of directories) {
+    await walk(dir, 0, maxDepth, source, models);
+  }
+  return models;
+}
+async function walk(dir, depth, maxDepth, source, models) {
+  let entries = [];
+  try {
+    entries = await readdir(dir);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const full = path3.join(dir, entry);
+    try {
+      const info = await stat(full);
+      if (info.isFile() && entry.toLowerCase().endsWith(".gguf")) {
+        models.push({
+          id: entry.replace(/\.gguf$/i, ""),
+          name: entry,
+          source,
+          sizeBytes: info.size,
+          artifactPath: full
+        });
+      } else if (info.isDirectory() && depth < maxDepth && !entry.startsWith(".")) {
+        await walk(full, depth + 1, maxDepth, source, models);
+      }
+    } catch {
+      continue;
+    }
+  }
+}
+var llamaCppAdapter = {
+  id: "llamacpp",
+  label: "llama.cpp",
+  async detect() {
+    const found = await detectLlamaCpp();
+    return found["llama-cli"] || found["llama-server"] || found["llama-bench"];
+  },
+  async version() {
+    return void 0;
+  },
+  async listModels() {
+    return [];
+  },
+  async resolveModel(id) {
+    if (!id.endsWith(".gguf")) return void 0;
+    return { id, path: id, format: "gguf" };
+  },
+  async benchmarkCapabilities() {
+    const found = await detectLlamaCpp();
+    return found["llama-bench"] ? ["llama-bench"] : ["none"];
+  }
+};
+
+// src/adapters/lmstudio/index.ts
+function lmStudioCandidateDirs() {
+  const home = os6.homedir();
+  return [
+    path4.join(home, ".lmstudio", "models"),
+    path4.join(home, ".cache", "lm-studio", "models"),
+    path4.join(home, "Library", "Application Support", "LM Studio", "models")
+  ];
+}
+async function existingDirs() {
+  const found = [];
+  for (const dir of lmStudioCandidateDirs()) {
+    try {
+      await access2(dir);
+      found.push(dir);
+    } catch {
+      continue;
+    }
+  }
+  return found;
+}
+var lmStudioAdapter = {
+  id: "lmstudio",
+  label: "LM Studio",
+  async detect() {
+    return (await existingDirs()).length > 0;
+  },
+  async version() {
+    return void 0;
+  },
+  async listModels() {
+    const dirs = await existingDirs();
+    return scanGgufDirectories(dirs, { maxDepth: 3, source: "lmstudio" });
+  },
+  async resolveModel(id) {
+    const models = await this.listModels();
+    const hit = models.find((model) => model.id === id || model.name === id);
+    if (!hit?.artifactPath) return void 0;
+    return { id: hit.id, path: hit.artifactPath, format: "gguf" };
+  },
+  async benchmarkCapabilities() {
+    return ["llama-bench"];
+  }
+};
+
+// src/models/discovery.ts
+function defaultGgufDirs() {
+  const home = os7.homedir();
+  return [
+    path5.join(home, "Models"),
+    path5.join(home, "models"),
+    path5.join(home, ".cache", "llama.cpp"),
+    path5.join(home, ".local", "share", "llama.cpp")
+  ];
+}
+async function discoverLocalModels() {
+  const config = await loadConfig();
+  const ollama = await ollamaAdapter.listModels();
+  const lmstudio = await lmStudioAdapter.listModels();
+  const gguf = await scanGgufDirectories([...defaultGgufDirs(), ...config.modelPaths], { maxDepth: 1 });
+  const seen = /* @__PURE__ */ new Set();
+  const merged = [];
+  for (const model of [...ollama, ...lmstudio, ...gguf]) {
+    const key = `${model.source}:${model.id}:${model.artifactPath ?? ""}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    merged.push(model);
+  }
+  return merged;
+}
+
+// src/adapters/mlx/index.ts
+var mlxAdapter = {
+  id: "mlx",
+  label: "MLX",
+  async detect() {
+    return Boolean(await commandExists("mlx_lm"));
+  },
+  async version() {
+    return void 0;
+  },
+  async listModels() {
+    return [];
+  },
+  async resolveModel() {
+    return void 0;
+  },
+  async benchmarkCapabilities() {
+    return ["none"];
+  }
+};
+
+// src/runtimes/registry.ts
+var runtimes = [ollamaAdapter, llamaCppAdapter, lmStudioAdapter, mlxAdapter];
+async function detectRuntimes() {
+  const llamaBench = Boolean(await commandExists("llama-bench"));
+  const statuses = [];
+  for (const runtime of runtimes) {
+    const detected = await runtime.detect();
+    const version = detected ? await runtime.version() : void 0;
+    statuses.push({ id: runtime.id, label: runtime.label, detected, version });
+  }
+  statuses.push({
+    id: "llama-bench",
+    label: "llama-bench",
+    detected: llamaBench
+  });
+  return statuses;
+}
+
+// src/adapters/canirun/schema.ts
+import { z as z2 } from "zod";
+var catalogModelSchema = z2.object({
+  id: z2.string(),
+  name: z2.string(),
+  provider: z2.string().optional(),
+  family: z2.string().optional(),
+  params: z2.string().optional(),
+  paramsBillions: z2.number().optional(),
+  architecture: z2.string().optional(),
+  useCase: z2.array(z2.string()).optional(),
+  url: z2.string().optional()
+});
+var catalogResponseSchema = z2.object({
+  count: z2.number().optional(),
+  models: z2.array(catalogModelSchema)
+});
+var compatibilityResponseSchema = z2.object({
+  compatible: z2.boolean().optional(),
+  status: z2.string().optional(),
+  grade: z2.enum(["S", "A", "B", "C", "D", "F"]),
+  score: z2.number().optional(),
+  modelId: z2.string().optional(),
+  quantization: z2.string().optional(),
+  recommendedQuantization: z2.string().optional(),
+  estimated: z2.object({
+    tokensPerSecond: z2.number().optional(),
+    modelSizeGb: z2.number().optional(),
+    vramRequiredGb: z2.number().optional(),
+    ramRequiredGb: z2.number().optional(),
+    memoryHeadroomGb: z2.number().optional()
+  }).optional(),
+  notes: z2.array(z2.string()).optional()
+});
+var recommendItemSchema = z2.object({
+  modelId: z2.string().optional(),
+  id: z2.string().optional(),
+  name: z2.string().optional(),
+  grade: z2.enum(["S", "A", "B", "C", "D", "F"]).optional(),
+  quantization: z2.string().optional(),
+  useCase: z2.array(z2.string()).optional(),
+  estimated: z2.object({
+    tokensPerSecond: z2.number().optional()
+  }).optional()
+}).passthrough();
+var recommendResponseSchema = z2.object({
+  recommendations: z2.array(recommendItemSchema).optional()
+}).passthrough();
+
+// src/adapters/canirun/index.ts
+var BASE = "https://canirun.ai";
+function hardwarePayload(hardware) {
+  return {
+    cpu: {
+      name: hardware.cpu.name,
+      cores: hardware.cpu.physicalCores,
+      threads: hardware.cpu.logicalCores
+    },
+    ramGb: Number(bytesToGiB(hardware.memory.totalBytes).toFixed(1)),
+    gpu: hardware.gpu.name ? { name: hardware.gpu.name } : void 0
+  };
+}
+async function postJson(path7, body, timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(`${BASE}${path7}`, {
+      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}`);
+    return await response.json();
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function getJson(path7, timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(`${BASE}${path7}`, {
+      headers: { accept: "application/json" },
+      signal: controller.signal
+    });
+    if (!response.ok) throw new Error(`CanIRun ${path7} ${response.status}`);
+    return await response.json();
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function fetchCatalog() {
+  const json = await getJson("/api/models", 15e3);
+  const parsed = catalogResponseSchema.parse(json);
+  return parsed.models;
+}
+async function fetchCompatibility(hardware, modelId) {
+  const json = await postJson(
+    "/api/compatibility",
+    { hardware: hardwarePayload(hardware), modelId },
+    15e3
+  );
+  const parsed = compatibilityResponseSchema.parse(json);
+  return {
+    modelId: parsed.modelId ?? modelId,
+    source: "estimated",
+    grade: parsed.grade,
+    status: parsed.status,
+    recommendedQuantization: parsed.recommendedQuantization ?? parsed.quantization,
+    estimatedTokensPerSecond: parsed.estimated?.tokensPerSecond,
+    estimatedRamGb: parsed.estimated?.ramRequiredGb ?? parsed.estimated?.vramRequiredGb,
+    notes: parsed.notes
+  };
+}
+async function fetchRecommendations(hardware, useCase, limit = 5) {
+  const json = await postJson(
+    "/api/recommend",
+    { hardware: hardwarePayload(hardware), useCase, limit },
+    15e3
+  );
+  const parsed = recommendResponseSchema.parse(json);
+  const items = parsed.recommendations ?? [];
+  return items.map((item) => ({
+    useCase: useCase ?? "general",
+    model: {
+      id: String(item.modelId ?? item.id ?? "unknown"),
+      name: String(item.name ?? item.modelId ?? item.id ?? "unknown")
+    },
+    grade: item.grade ?? "C",
+    quantization: item.quantization,
+    estimatedTokensPerSecond: item.estimated?.tokensPerSecond
+  }));
+}
+
+// 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) {
+  await ensureStorage();
+  const payload = { savedAt: (/* @__PURE__ */ new Date()).toISOString(), models };
+  await writeFile2(canirunCachePath(), `${JSON.stringify(payload, null, 2)}
+`, "utf8");
+}
+async function loadCatalogCache() {
+  try {
+    const raw = await readFile2(canirunCachePath(), "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed.models;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/i18n/en.ts
+var en = {
+  appTitle: "PUDU-AI",
+  appSubtitle: "Local AI Hardware & Benchmark Lab",
+  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.",
+  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: "[B] Benchmark  [M] Models  [R] Recommend  [T] Tasks  [H] Hardware  [C] Compare  [L] History  [Q] Quit",
+  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",
+  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 recommend
+  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",
+  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.",
+  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: "[B] Benchmark  [M] Modelos  [R] Recomendaciones  [T] Tareas  [H] Hardware  [C] Comparar  [L] Historial  [Q] Salir",
+  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",
+  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 recommend
+  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/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"] },
+  { id: "qwen3-8b", name: "Qwen 3 8B", provider: "Alibaba", paramsBillions: 8, useCase: ["code", "chat", "reasoning"] },
+  { id: "qwen3-4b", name: "Qwen 3 4B", provider: "Alibaba", paramsBillions: 4, useCase: ["chat"] },
+  { id: "qwen3.5-4b", name: "Qwen 3.5 4B", provider: "Alibaba", paramsBillions: 4, useCase: ["chat"] },
+  { id: "deepseek-r1-8b", name: "DeepSeek R1 8B", provider: "DeepSeek", paramsBillions: 8, useCase: ["reasoning"] },
+  { id: "qwen3-14b", name: "Qwen 3 14B", provider: "Alibaba", paramsBillions: 14, useCase: ["chat", "reasoning"] },
+  { id: "llama3.1-8b", name: "Llama 3.1 8B", provider: "Meta", paramsBillions: 8, useCase: ["chat", "code"] }
+];
+async function loadCatalog(network) {
+  if (network) {
+    try {
+      const models = await fetchCatalog();
+      await saveCatalogCache(models);
+      return { catalog: models, networkUsed: true };
+    } catch {
+      const cached2 = await loadCatalogCache();
+      if (cached2?.length) return { catalog: cached2, networkUsed: false };
+    }
+  }
+  const cached = await loadCatalogCache();
+  return { catalog: cached?.length ? cached : FALLBACK_CATALOG, networkUsed: false };
+}
+function matchCatalog(catalog, local) {
+  return catalog.find((model) => idsLikelyMatch(model.id, local.id) || idsLikelyMatch(model.name, local.name));
+}
+async function compatibilityFor(hardware, catalogModel, network) {
+  if (network) {
+    try {
+      return await fetchCompatibility(hardware, catalogModel.id);
+    } catch {
+      return localCompatibility(hardware, catalogModel);
+    }
+  }
+  return localCompatibility(hardware, catalogModel);
+}
+async function recommendForMachine(hardware, catalog, network) {
+  const useCases = ["code", "chat", "reasoning", "edge"];
+  if (network) {
+    try {
+      const rows = [];
+      for (const useCase of useCases) {
+        const found = await fetchRecommendations(hardware, useCase, 1);
+        rows.push(...found.map((item) => ({ ...item, useCase: labelUseCase(useCase) })));
+      }
+      if (rows.length) return rows;
+    } catch {
+    }
+  }
+  const ranked = catalog.map((model) => ({ model, result: localCompatibility(hardware, model) })).filter((row) => row.result.grade !== "F").sort((a, b) => a.result.grade.localeCompare(b.result.grade));
+  const picks = [];
+  const used = /* @__PURE__ */ new Set();
+  for (const useCase of useCases) {
+    const hit = ranked.find((row) => {
+      if (used.has(row.model.id)) return false;
+      if (useCase === "chat") return row.model.useCase?.includes("chat") ?? true;
+      return row.model.useCase?.some((u) => u.includes(useCase)) ?? false;
+    });
+    if (!hit) continue;
+    used.add(hit.model.id);
+    picks.push({
+      useCase: labelUseCase(useCase),
+      model: hit.model,
+      grade: hit.result.grade,
+      estimatedTokensPerSecond: hit.result.estimatedTokensPerSecond
+    });
+  }
+  return picks;
+}
+function labelUseCase(useCase) {
+  if (useCase === "code") return t("useCaseCoding");
+  if (useCase === "reasoning") return t("useCaseReasoning");
+  if (useCase === "edge") return t("useCaseLightweight");
+  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
+async function loadSession(options) {
+  const hardware = await detectHardware();
+  const [runtimes2, models, catalogState, history, llamaBench] = await Promise.all([
+    detectRuntimes(),
+    discoverLocalModels(),
+    loadCatalog(options.network),
+    listBenchmarks(),
+    commandExists("llama-bench").then(Boolean)
+  ]);
+  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 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);
+  return {
+    hardware,
+    runtimes: runtimes2,
+    models,
+    catalog: catalogState.catalog,
+    rows,
+    recommendations,
+    history,
+    llamaBench,
+    networkUsed: catalogState.networkUsed
+  };
+}
+
+// src/telemetry/macos.ts
+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/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 Box9, Text as Text9, useApp, useInput as useInput3 } from "ink";
+import { useMemo as useMemo2, useState as useState3 } from "react";
+
+// src/tui/views/Dashboard.tsx
+import { Box, Text } 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/compatibility/types.ts
+var GRADE_MEANING = {
+  S: "Excellent",
+  A: "Recommended",
+  B: "Good",
+  C: "Tight",
+  D: "CPU/offload",
+  F: "Not recommended"
+};
+
+// src/tui/views/Dashboard.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function Dashboard({ session }) {
+  const h = session.hardware;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs(Box, { borderStyle: "round", borderColor: "cyan", flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: t("appTitle") }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: t("appSubtitle") }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: t("aboutDashboard") })
+    ] }),
+    /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: t("machine") }),
+    /* @__PURE__ */ jsx(Text, { children: h.machineModel ?? t("unknownMachine") }),
+    /* @__PURE__ */ jsx(Text, { children: h.cpu.name ?? t("cpuNa") }),
+    /* @__PURE__ */ jsxs(Text, { children: [
+      "CPU           ",
+      h.cpu.physicalCores ?? "N/A",
+      " cores",
+      h.cpu.performanceCores ? `  (${h.cpu.performanceCores}P/${h.cpu.efficiencyCores ?? "?"}E)` : ""
+    ] }),
+    /* @__PURE__ */ jsxs(Text, { children: [
+      "GPU           ",
+      h.gpu.name ?? "N/A"
+    ] }),
+    /* @__PURE__ */ jsxs(Text, { children: [
+      memoryLabel(h).padEnd(13),
+      " ",
+      formatBytes(h.memory.totalBytes, 0)
+    ] }),
+    /* @__PURE__ */ jsxs(Text, { children: [
+      "Available     ",
+      h.memory.availableBytes ? formatBytes(h.memory.availableBytes) : "N/A"
+    ] }),
+    /* @__PURE__ */ jsxs(Text, { children: [
+      h.os,
+      "         ",
+      h.osVersion ?? h.arch
+    ] }),
+    /* @__PURE__ */ jsxs(Box, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: t("runtimes") }),
+      session.runtimes.map((r) => /* @__PURE__ */ jsxs(Text, { children: [
+        r.detected ? "\u2713" : "\u25CB",
+        " ",
+        r.label.padEnd(14),
+        " ",
+        r.detected ? r.version ?? t("detected") : t("notDetected")
+      ] }, r.id))
+    ] }),
+    /* @__PURE__ */ jsxs(Box, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: t("installedModels") }),
+      session.rows.length === 0 && /* @__PURE__ */ jsx(Text, { dimColor: true, children: t("noModels") }),
+      session.rows.map((row) => /* @__PURE__ */ jsxs(Text, { children: [
+        row.local.name.padEnd(20),
+        " ",
+        row.local.sizeBytes ? formatBytes(row.local.sizeBytes) : "N/A",
+        "  ",
+        row.compatibility?.grade ?? "\u2014",
+        "  ",
+        row.lastBenchmark?.benchmark.generationTokensPerSecond ? formatTokensPerSec(row.lastBenchmark.benchmark.generationTokensPerSecond) : t("notTested")
+      ] }, row.local.id))
+    ] }),
+    /* @__PURE__ */ jsxs(Box, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: t("recommended") }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: t("recommendedHint") }),
+      session.recommendations.map((rec) => /* @__PURE__ */ jsxs(Text, { children: [
+        rec.useCase.padEnd(12),
+        " ",
+        rec.model.name.padEnd(22),
+        " ",
+        rec.grade,
+        " ",
+        GRADE_MEANING[rec.grade]
+      ] }, `${rec.useCase}-${rec.model.id}`)),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: t("credits") })
+    ] })
+  ] });
+}
+
+// src/tui/views/Models.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+
+// 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 [
+    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 [
+    t("runtimes"),
+    ...session.runtimes.map((r) => `  ${r.detected ? "\u2713" : "\u25CB"} ${r.label.padEnd(14)} ${r.detected ? r.version ?? t("detected") : t("notDetected")}`)
+  ].join("\n");
+}
+function modelsText(session) {
+  const lines = [t("installedModels"), "MODEL                 INSTALLED   FIT       EST. SPEED     MEASURED"];
+  for (const row of session.rows) {
+    const fit = 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(
+      `${row.local.name.padEnd(22)} \u2713           ${fit.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 = [t("recommended"), t("recommendedHint"), "", t("credits"), ""];
+  for (const rec of session.recommendations) {
+    lines.push(
+      `${rec.useCase.padEnd(12)} ${rec.model.name.padEnd(22)} ${rec.grade}  ${GRADE_MEANING[rec.grade]}  ~${na(rec.estimatedTokensPerSecond)} t/s est.`
+    );
+  }
+  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.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 jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function ModelsView({ session }) {
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx2(Text2, { children: modelsText(session) }),
+    /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: t("modelsHint") })
+  ] });
+}
+
+// src/tui/views/Hardware.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function HardwareView({ session }) {
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx3(Text3, { children: hardwareText(session) }),
+    /* @__PURE__ */ jsx3(Text3, { children: runtimesText(session) }),
+    /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: t("hardwareHint") })
+  ] });
+}
+
+// src/tui/views/Recommend.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+import { jsx as jsx4 } from "react/jsx-runtime";
+function RecommendView({ session }) {
+  return /* @__PURE__ */ jsx4(Box4, { flexDirection: "column", children: /* @__PURE__ */ jsx4(Text4, { children: recommendText(session) }) });
+}
+
+// src/tui/views/Compare.tsx
+import { Box as Box5, Text as Text5 } from "ink";
+import { jsx as jsx5 } from "react/jsx-runtime";
+function CompareView({ session }) {
+  return /* @__PURE__ */ jsx5(Box5, { flexDirection: "column", children: /* @__PURE__ */ jsx5(Text5, { children: compareText(session.history) }) });
+}
+
+// src/tui/views/Benchmark.tsx
+import { Box as Box6, Text as Text6, useInput } from "ink";
+import { useEffect, useRef, useState } from "react";
+
+// src/tui/theme.ts
+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/views/Benchmark.tsx
+import { jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
+function BenchmarkView(props) {
+  const [phase, setPhase] = useState(props.models.length ? "select" : "error");
+  const [sample, setSample] = useState();
+  const [elapsed, setElapsed] = useState(0);
+  const [result, setResult] = useState();
+  const [error, setError] = useState(props.models.length ? "" : t("noGguf"));
+  const cpuHist = useRef([]);
+  const memHist = useRef([]);
+  const abortRef = useRef(void 0);
+  useInput((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();
+    }
+  });
+  useEffect(() => {
+    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__ */ jsxs4(Box6, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx6(Text6, { bold: true, children: t("selectBenchmark") }),
+      props.models.map((m, i) => /* @__PURE__ */ jsxs4(Text6, { color: i === props.selected ? "cyan" : void 0, children: [
+        i === props.selected ? "\u276F " : "  ",
+        m.name
+      ] }, m.id)),
+      /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: t("enterToRun") })
+    ] });
+  }
+  if (phase === "done" && result) {
+    return /* @__PURE__ */ jsxs4(Box6, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx6(Text6, { children: resultText(result.record, result.assessment) }),
+      /* @__PURE__ */ jsxs4(Text6, { dimColor: true, children: [
+        t("saved"),
+        " ",
+        result.path
+      ] })
+    ] });
+  }
+  if (phase === "error") {
+    return /* @__PURE__ */ jsx6(Box6, { flexDirection: "column", children: /* @__PURE__ */ jsx6(Text6, { 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__ */ jsxs4(Box6, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs4(Box6, { borderStyle: "round", borderColor: "cyan", flexDirection: "column", paddingX: 1, children: [
+      /* @__PURE__ */ jsx6(Text6, { bold: true, children: t("benchmarkTitle") }),
+      /* @__PURE__ */ jsx6(Text6, { children: model?.name }),
+      /* @__PURE__ */ jsxs4(Text6, { dimColor: true, children: [
+        h.cpu.name,
+        " \xB7 ",
+        formatBytes(h.memory.totalBytes, 0),
+        " ",
+        memoryLabel(h)
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs4(Box6, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx6(Text6, { bold: true, color: "cyan", children: t("performance") }),
+      /* @__PURE__ */ jsxs4(Text6, { children: [
+        t("elapsed"),
+        "                    ",
+        elapsed.toFixed(1),
+        " s"
+      ] }),
+      /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: t("measuredAfter") })
+    ] }),
+    /* @__PURE__ */ jsxs4(Box6, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx6(Text6, { bold: true, color: "cyan", children: t("system") }),
+      /* @__PURE__ */ jsxs4(Text6, { children: [
+        "CPU       ",
+        bar(cpu),
+        "       ",
+        formatPercent(cpu)
+      ] }),
+      /* @__PURE__ */ jsxs4(Text6, { children: [
+        "GPU       ",
+        bar(gpu),
+        "       ",
+        formatPercent(gpu)
+      ] }),
+      /* @__PURE__ */ jsxs4(Text6, { children: [
+        "Memory    ",
+        bar(memUsed && memTotal ? memUsed / memTotal * 100 : void 0),
+        "      ",
+        memUsed ? formatBytes(memUsed) : "N/A",
+        " / ",
+        formatBytes(memTotal, 0)
+      ] }),
+      /* @__PURE__ */ jsxs4(Text6, { children: [
+        "Swap      ",
+        bar(0),
+        "      ",
+        sample ? formatBytes(sample.memory.swapUsedBytes) : "N/A"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs4(Box6, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx6(Text6, { bold: true, color: "cyan", children: t("powerThermals") }),
+      /* @__PURE__ */ jsxs4(Text6, { children: [
+        "Package                    ",
+        sample?.packagePowerWatts ?? "N/A",
+        " W"
+      ] }),
+      /* @__PURE__ */ jsxs4(Text6, { children: [
+        "Temperature                ",
+        sample?.thermal?.temperatureC ?? "N/A",
+        " \xB0C"
+      ] }),
+      /* @__PURE__ */ jsxs4(Text6, { children: [
+        "Thermal Pressure           ",
+        sample?.thermal?.pressure ?? "N/A"
+      ] }),
+      /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: t("permissionsHint") })
+    ] }),
+    /* @__PURE__ */ jsxs4(Text6, { children: [
+      sparkline(cpuHist.current),
+      " CPU"
+    ] }),
+    /* @__PURE__ */ jsxs4(Text6, { children: [
+      sparkline(memHist.current.map((v) => v / 1024 ** 3)),
+      " Memory"
+    ] }),
+    /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: t("cancelHint") })
+  ] });
+}
+
+// src/tui/views/History.tsx
+import { Box as Box7, Text as Text7 } from "ink";
+import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
+function HistoryView({ session }) {
+  return /* @__PURE__ */ jsxs5(Box7, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx7(Text7, { bold: true, color: "cyan", children: t("measured") }),
+    /* @__PURE__ */ jsx7(Text7, { children: historyText(session.history) })
+  ] });
+}
+
+// src/tui/views/Tasks.tsx
+import { Box as Box8, Text as Text8, useInput as useInput2 } from "ink";
+import { useMemo, useState as useState2 } 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 fit = localCompatibility(session.hardware, model);
+    return {
+      modelId: model.id,
+      modelName: model.name,
+      installed: false,
+      origin: "estimated",
+      grade: fit.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 jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
+var KIND_LABEL = {
+  code: "tasksOptCode",
+  video: "tasksOptVideo",
+  image: "tasksOptImage",
+  transcription: "tasksOptTranscription",
+  chat: "tasksOptChat"
+};
+function TasksView({ session }) {
+  const [step, setStep] = useState2(0);
+  const [cursor, setCursor] = useState2(0);
+  const [kinds, setKinds] = useState2(["code", "chat"]);
+  const [scope, setScope] = useState2("installed");
+  const [priority, setPriority] = useState2("balanced");
+  const plans = useMemo(
+    () => planTasks(session, { kinds, scope, priority }),
+    [session, kinds, scope, priority]
+  );
+  useInput2((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__ */ jsx8(Box8, { flexDirection: "column", children: /* @__PURE__ */ jsx8(Text8, { children: tasksText(plans, { kinds, scope, priority }) }) });
+  }
+  return /* @__PURE__ */ jsxs6(Box8, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx8(Text8, { bold: true, color: "cyan", children: t("tasksTitle") }),
+    step === 0 && /* @__PURE__ */ jsxs6(Fragment, { children: [
+      /* @__PURE__ */ jsx8(Text8, { children: t("tasksQ1") }),
+      WORK_KINDS.map((kind, i) => /* @__PURE__ */ jsxs6(Text8, { color: i === cursor ? "cyan" : void 0, children: [
+        i === cursor ? "\u276F " : "  ",
+        "[",
+        kinds.includes(kind) ? "x" : " ",
+        "] ",
+        t(KIND_LABEL[kind])
+      ] }, kind))
+    ] }),
+    step === 1 && /* @__PURE__ */ jsxs6(Fragment, { children: [
+      /* @__PURE__ */ jsx8(Text8, { children: t("tasksQ2") }),
+      /* @__PURE__ */ jsxs6(Text8, { color: scope === "installed" ? "cyan" : void 0, children: [
+        scope === "installed" ? "\u276F " : "  ",
+        t("tasksOptInstalled")
+      ] }),
+      /* @__PURE__ */ jsxs6(Text8, { color: scope === "all" ? "cyan" : void 0, children: [
+        scope === "all" ? "\u276F " : "  ",
+        t("tasksOptAll")
+      ] })
+    ] }),
+    step === 2 && /* @__PURE__ */ jsxs6(Fragment, { children: [
+      /* @__PURE__ */ jsx8(Text8, { children: t("tasksQ3") }),
+      ["speed", "balanced", "quality"].map((item) => /* @__PURE__ */ jsxs6(Text8, { color: priority === item ? "cyan" : void 0, children: [
+        priority === item ? "\u276F " : "  ",
+        item === "speed" ? t("tasksOptSpeed") : item === "quality" ? t("tasksOptQuality") : t("tasksOptBalanced")
+      ] }, item))
+    ] })
+  ] });
+}
+
+// src/tui/App.tsx
+import { jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
+function App(props) {
+  const { exit } = useApp();
+  const [screen, setScreen] = useState3("home");
+  const [selected, setSelected] = useState3(0);
+  const benchable = useMemo2(
+    () => props.session.models.filter((m) => Boolean(m.artifactPath)),
+    [props.session.models]
+  );
+  useInput3((input, key) => {
+    if (screen === "benchmark") return;
+    const letter = input.toLowerCase();
+    if (letter === "q" || key.escape) exit();
+    if (letter === "b") setScreen("benchmark");
+    if (letter === "m") setScreen("models");
+    if (letter === "r") setScreen("recommend");
+    if (letter === "h") setScreen("hardware");
+    if (letter === "c") setScreen("compare");
+    if (letter === "l") setScreen("history");
+    if (letter === "t") setScreen("tasks");
+    if (key.return && screen === "home") setScreen("benchmark");
+  });
+  return /* @__PURE__ */ jsxs7(Box9, { flexDirection: "column", padding: 1, children: [
+    screen === "home" && /* @__PURE__ */ jsx9(Dashboard, { session: props.session }),
+    screen === "models" && /* @__PURE__ */ jsx9(ModelsView, { session: props.session }),
+    screen === "hardware" && /* @__PURE__ */ jsx9(HardwareView, { session: props.session }),
+    screen === "recommend" && /* @__PURE__ */ jsx9(RecommendView, { session: props.session }),
+    screen === "compare" && /* @__PURE__ */ jsx9(CompareView, { session: props.session }),
+    screen === "history" && /* @__PURE__ */ jsx9(HistoryView, { session: props.session }),
+    screen === "tasks" && /* @__PURE__ */ jsx9(TasksView, { session: props.session }),
+    screen === "benchmark" && /* @__PURE__ */ jsx9(
+      BenchmarkView,
+      {
+        session: props.session,
+        models: benchable,
+        selected,
+        setSelected,
+        preset: props.preset,
+        onBack: () => setScreen("home")
+      }
+    ),
+    screen !== "benchmark" && /* @__PURE__ */ jsx9(Box9, { marginTop: 1, children: /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: t("nav") }) })
+  ] });
+}
+
+// src/tui/render.tsx
+import { jsx as jsx10 } from "react/jsx-runtime";
+async function renderDashboard(session, preset) {
+  const instance = render(/* @__PURE__ */ jsx10(App, { session, preset }));
+  await instance.waitUntilExit();
+}
+
+// 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 toOllamaTag(id) {
+  const compact = id.toLowerCase().replace(/_/g, "-");
+  const match = compact.match(/^([a-z0-9.]+(?:-[a-z0-9.]+)*)-(\d+(?:\.\d+)?b)$/i);
+  if (match) return `${match[1]}:${match[2]}`;
+  if (compact.includes(":")) return compact;
+  return compact;
+}
+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 tps = row.lastBenchmark?.benchmark.generationTokensPerSecond;
+    candidates.push({
+      modelId: row.local.id,
+      ollamaTag: row.local.id.includes(":") ? row.local.id : toOllamaTag(row.local.id),
+      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 fit = localCompatibility(session.hardware, model);
+      if (!def.allowedGrades.includes(fit.grade)) continue;
+      candidates.push({
+        modelId: model.id,
+        ollamaTag: toOllamaTag(model.id),
+        installed: false,
+        origin: "estimated",
+        grade: fit.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
+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() };
+}
+
+// src/cli/help.ts
+function helpText() {
+  return t("help");
+}
+
+// src/cli/run.ts
+function print(value, json) {
+  if (json) {
+    process.stdout.write(`${JSON.stringify(value, null, 2)}
+`);
+    return;
+  }
+  process.stdout.write(`${typeof value === "string" ? value : JSON.stringify(value, null, 2)}
+`);
+}
+function explained(aboutKey, body) {
+  return `${t(aboutKey)}
+
+${body}`;
+}
+async function run(args2) {
+  setLocale(resolveLocale(args2.lang));
+  if (args2.help) {
+    process.stdout.write(`${helpText()}
+`);
+    return 0;
+  }
+  if (args2.verbose) setLogLevel("verbose");
+  if (!args2.color) process.env.NO_COLOR = "1";
+  const cleanup = () => {
+    void killAll("SIGTERM");
+  };
+  process.on("SIGINT", () => {
+    cleanup();
+    process.exit(130);
+  });
+  if (args2.addPath) {
+    await addModelPath(args2.addPath);
+    print(args2.json ? { path: args2.addPath } : explained("aboutAddPath", t("addedPath", { path: args2.addPath })), args2.json);
+    return 0;
+  }
+  if (!args2.json && !args2.csv && process.stderr.isTTY) {
+    process.stderr.write(`${t("loading")}
+`);
+  }
+  const session = await loadSession({ network: args2.network });
+  switch (args2.command) {
+    case "hardware":
+      print(
+        args2.json ? session.hardware : explained("aboutHardware", `${hardwareText(session)}
+
+${runtimesText(session)}`),
+        args2.json
+      );
+      return 0;
+    case "models":
+      print(args2.json ? session.rows : explained("aboutModels", modelsText(session)), args2.json);
+      return 0;
+    case "recommend":
+      print(args2.json ? session.recommendations : explained("aboutRecommend", recommendText(session)), args2.json);
+      return 0;
+    case "launch": {
+      const tool = parseIntegration(args2.positional[0]);
+      const decisions = tool ? [decideLaunch(session, tool)] : decideAll(session);
+      if (!args2.yes) {
+        print(args2.json ? decisions : explained("aboutLaunch", launchText(decisions)), args2.json);
+        return 0;
+      }
+      if (!tool) {
+        process.stderr.write(`${t("launchNeedTool")}
+`);
+        return 1;
+      }
+      const decision = decisions[0];
+      if (!decision.eligible) {
+        print(args2.json ? decision : explained("aboutLaunch", launchText([decision])), args2.json);
+        return 1;
+      }
+      const result = await executeLaunch(decision);
+      print(args2.json ? { decision, result } : explained("aboutLaunch", result.log), args2.json);
+      return result.ok ? 0 : 1;
+    }
+    case "tasks": {
+      const answers = parseAnswers({
+        for: args2.forKinds,
+        scope: args2.scope,
+        priority: args2.priority
+      });
+      const plans = planTasks(session, answers);
+      print(args2.json ? { answers, plans } : explained("aboutTasks", tasksText(plans, answers)), args2.json);
+      return 0;
+    }
+    case "history": {
+      const records = session.history;
+      if (args2.csv) {
+        process.stdout.write(`${historyCsv(records)}
+`);
+        return 0;
+      }
+      print(args2.json ? records : explained("aboutHistory", historyText(records)), args2.json);
+      return 0;
+    }
+    case "doctor":
+      print(args2.json ? session : explained("aboutDoctor", doctorText(session)), args2.json);
+      return 0;
+    case "compare":
+      print(args2.json ? session.history : explained("aboutCompare", compareText(session.history)), args2.json);
+      return 0;
+    case "report": {
+      const last = session.history.at(-1);
+      if (!last) {
+        process.stderr.write(`${t("noHistory")}
+`);
+        return 1;
+      }
+      process.stdout.write(`${explained("aboutReport", reportMarkdown(last))}
+`);
+      return 0;
+    }
+    case "benchmark": {
+      const id = args2.positional[0];
+      if (!id) {
+        if (args2.json) {
+          print({ error: t("jsonNeedModel") }, true);
+          return 1;
+        }
+        await renderDashboard(session, args2.preset);
+        return 0;
+      }
+      const model = session.models.find((m) => m.id === id || m.name === id);
+      if (!model) {
+        process.stderr.write(`${t("modelNotFound", { id })}
+`);
+        return 1;
+      }
+      const catalog = session.rows.find((r) => r.local.id === model.id)?.catalog;
+      const result = await runBenchmark({
+        model,
+        hardware: session.hardware,
+        preset: args2.preset,
+        catalog
+      });
+      if (args2.json) {
+        print(result.record, true);
+        return 0;
+      }
+      process.stdout.write(`${explained("aboutBenchmark", resultText(result.record, result.assessment))}
+`);
+      return 0;
+    }
+    case "dashboard":
+    default:
+      if (args2.json) {
+        print(session, true);
+        return 0;
+      }
+      await renderDashboard(session, args2.preset);
+      return 0;
+  }
+}
+
+// src/cli/index.ts
+var args = parseArgs(process.argv);
+run(args).then((code) => {
+  process.exitCode = code;
+}).catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`${message}
+`);
+  process.exitCode = 1;
+});