pudu-ai 0.2.18 → 0.2.21

package/dist/cli/chunk-6C5EPKRI.js

@@ -0,0 +1,1597 @@
+import {
+  formatNumber,
+  formatTokensPerSec,
+  na,
+  t
+} from "./chunk-QGEXKMQ5.js";
+import {
+  commandExists,
+  runCommand,
+  spawnTracked,
+  toText
+} from "./chunk-SS7OXXQQ.js";
+
+// src/storage/benchmarks.ts
+import { readdir, readFile, writeFile } from "node:fs/promises";
+import path2 from "node:path";
+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/benchmarks.ts
+var benchmarkRecordSchema = z.object({
+  schemaVersion: z.literal(1),
+  timestamp: z.string(),
+  machine: z.record(z.unknown()),
+  model: z.object({
+    id: z.string(),
+    name: z.string().optional(),
+    source: z.string().optional(),
+    path: z.string().optional()
+  }),
+  runtime: z.object({
+    name: z.string(),
+    command: z.array(z.string()).optional()
+  }),
+  benchmark: z.object({
+    promptTokens: z.number(),
+    generationTokens: z.number(),
+    repetitions: z.number(),
+    promptTokensPerSecond: z.number().optional(),
+    generationTokensPerSecond: z.number().optional(),
+    elapsedSeconds: z.number().optional()
+  }),
+  resources: z.object({
+    peakMemoryGb: z.number().optional(),
+    peakSwapGb: z.number().optional(),
+    avgGpuPercent: z.number().optional(),
+    avgCpuPercent: z.number().optional(),
+    peakGpuPercent: z.number().optional(),
+    avgPackagePowerWatts: z.number().optional(),
+    peakPackagePowerWatts: z.number().optional(),
+    avgTemperatureC: z.number().optional(),
+    peakTemperatureC: z.number().optional(),
+    tokensPerSecondPerWatt: z.number().optional(),
+    peakProcessRssGb: z.number().optional()
+  }),
+  score: z.object({
+    total: z.number(),
+    speed: z.string().optional(),
+    memory: z.string().optional(),
+    energy: z.string().optional(),
+    thermal: z.string().optional(),
+    swap: z.string().optional()
+  }).optional(),
+  origin: z.enum(["measured"]).default("measured")
+});
+async function saveBenchmark(record) {
+  await ensureStorage();
+  const safeName = record.model.id.replace(/[^a-zA-Z0-9._-]+/g, "-");
+  const file = path2.join(benchmarksDir(), `${record.timestamp.replace(/[:.]/g, "-")}-${safeName}.json`);
+  await writeFile(file, `${JSON.stringify(record, null, 2)}
+`, "utf8");
+  return file;
+}
+async function listBenchmarks() {
+  await ensureStorage();
+  let files = [];
+  try {
+    files = (await readdir(benchmarksDir())).filter((f) => f.endsWith(".json"));
+  } catch {
+    return [];
+  }
+  const records = [];
+  for (const file of files.sort()) {
+    try {
+      const raw = await readFile(path2.join(benchmarksDir(), file), "utf8");
+      records.push(benchmarkRecordSchema.parse(JSON.parse(raw)));
+    } catch {
+      continue;
+    }
+  }
+  return records;
+}
+
+// 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/hardware/detect.ts
+import os5 from "node:os";
+
+// src/platform/macos/hardware.ts
+import os2 from "node:os";
+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/telemetry/macos.ts
+import os7 from "node:os";
+
+// src/telemetry/fallback.ts
+import os6 from "node:os";
+var previous = os6.cpus();
+function cpuPercent() {
+  const current = os6.cpus();
+  let idle = 0;
+  let total = 0;
+  for (let i = 0; i < current.length; i += 1) {
+    const c = current[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 = current;
+  if (total <= 0) return 0;
+  return Number((100 * (1 - idle / total)).toFixed(1));
+}
+var nodeTelemetry = {
+  async start() {
+    previous = os6.cpus();
+  },
+  async sample() {
+    const total = os6.totalmem();
+    const free = os6.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 = os7.totalmem();
+      const available = parsed.availableBytes ?? os7.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 z2 } from "zod";
+var jsonRowSchema = z2.object({
+  n_prompt: z2.number().optional(),
+  n_gen: z2.number().optional(),
+  avg_ts: z2.number().optional(),
+  model_type: z2.string().optional(),
+  model_size: z2.number().optional(),
+  backends: z2.string().optional(),
+  test: z2.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 args = [
+    "-m",
+    artifact,
+    "-p",
+    String(preset.promptTokens),
+    "-n",
+    String(preset.generationTokens),
+    "-r",
+    String(preset.repetitions),
+    "-o",
+    "json"
+  ];
+  const subprocess = spawnTracked(bench, args, { 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, ...args] },
+    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 path3 = await saveBenchmark(record);
+  input.onProgress?.({
+    elapsedSeconds: record.benchmark.elapsedSeconds ?? 0,
+    status: "completed"
+  });
+  return {
+    record,
+    assessment: assessRun({
+      generationTokensPerSecond: metrics.generationTokensPerSecond,
+      resources,
+      catalog: input.catalog
+    }),
+    path: path3,
+    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/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/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/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 installed = 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 = [...installed, ...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/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/ollama-tags.ts
+var RULES = [
+  { test: /qwen\s*3\.5\s*[-:]?\s*8b/i, tag: "qwen3.5:8b" },
+  { test: /qwen\s*3\.5\s*[-:]?\s*4b/i, tag: "qwen3.5:4b" },
+  { test: /qwen\s*3\s*[-:]?\s*14b/i, tag: "qwen3:14b" },
+  { test: /qwen\s*3\s*[-:]?\s*8b/i, tag: "qwen3:8b" },
+  { test: /qwen\s*3\s*[-:]?\s*4b/i, tag: "qwen3:4b" },
+  { test: /qwen\s*2\.5\s*[-:]?\s*coder\s*[-:]?\s*7b/i, tag: "qwen2.5-coder:7b" },
+  { test: /gemma\s*3\s*[-:]?\s*12b/i, tag: "gemma3:12b" },
+  { test: /gemma\s*3\s*[-:]?\s*4b/i, tag: "gemma3:4b" },
+  { test: /gemma\s*3\s*[-:]?\s*1b/i, tag: "gemma3:1b" },
+  { test: /llama\s*3\.2\s*[-:]?\s*3b/i, tag: "llama3.2:3b" },
+  { test: /llama\s*3\.2\s*[-:]?\s*1b/i, tag: "llama3.2:1b" },
+  { test: /llama\s*3\.1\s*[-:]?\s*8b/i, tag: "llama3.1:8b" },
+  { test: /deepseek[- ]r1\s*[-:]?\s*8b|deepseek-r1-distill.*8b/i, tag: "deepseek-r1:8b" },
+  { test: /deepseek[- ]r1\s*[-:]?\s*7b/i, tag: "deepseek-r1:7b" },
+  { test: /mistral\s*[-:]?\s*7b|mistral-nemo/i, tag: "mistral:7b" },
+  { test: /phi\s*4|phi-4/i, tag: "phi4" }
+];
+function resolveOllamaTag(...parts) {
+  const haystack = parts.filter(Boolean).join(" ");
+  if (!haystack.trim()) return void 0;
+  if (/^[a-z0-9._-]+:[a-z0-9._-]+$/i.test(haystack.trim())) return haystack.trim();
+  for (const rule of RULES) {
+    if (rule.test.test(haystack)) return rule.tag;
+  }
+  return void 0;
+}
+
+// src/integrations/types.ts
+var INTEGRATION_IDS = ["opencode", "openclaw", "hermes", "claude"];
+
+// src/integrations/decide.ts
+var GRADE_RANK = { S: 5, A: 4, B: 3, C: 2, D: 1, F: 0 };
+function useCaseOk(useCases, needed) {
+  if (!useCases?.length) return needed.includes("chat");
+  return useCases.some((u) => needed.some((n) => u.includes(n)));
+}
+function decideLaunch(session, id) {
+  const def = INTEGRATIONS[id];
+  const reasons = [];
+  const ollama = session.runtimes.find((r) => r.id === "ollama")?.detected;
+  if (!ollama) reasons.push(t("launchNeedOllama"));
+  const candidates = [];
+  for (const row of session.rows) {
+    const useCases = row.catalog?.useCase ?? ["chat", "code"];
+    if (!useCaseOk(useCases, def.useCases)) continue;
+    const tag = resolveOllamaTag(row.local.id, row.local.name, row.catalog?.id, row.catalog?.name);
+    if (!tag) continue;
+    const tps = row.lastBenchmark?.benchmark.generationTokensPerSecond;
+    candidates.push({
+      modelId: row.local.id,
+      ollamaTag: tag,
+      installed: true,
+      origin: row.lastBenchmark ? "measured" : "estimated",
+      grade: row.compatibility?.grade,
+      tps
+    });
+  }
+  if (!candidates.length) {
+    for (const model of session.catalog) {
+      if (!useCaseOk(model.useCase, def.useCases)) continue;
+      const fit = localCompatibility(session.hardware, model);
+      if (!def.allowedGrades.includes(fit.grade)) continue;
+      const tag = resolveOllamaTag(model.id, model.name);
+      if (!tag) continue;
+      candidates.push({
+        modelId: model.id,
+        ollamaTag: tag,
+        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/agents.ts
+var AGENTS = [
+  {
+    id: "opencode",
+    label: "OpenCode",
+    bin: "opencode",
+    launch: "ollama launch opencode",
+    docs: "https://docs.ollama.com/integrations/opencode"
+  },
+  {
+    id: "hermes",
+    label: "Hermes",
+    bin: "hermes",
+    launch: "ollama launch hermes",
+    docs: "https://docs.ollama.com/integrations/hermes"
+  },
+  {
+    id: "openclaw",
+    label: "OpenClaw",
+    bin: "openclaw",
+    launch: "ollama launch openclaw",
+    docs: "https://docs.ollama.com/integrations/openclaw"
+  }
+];
+async function detectAgents() {
+  const out = [];
+  for (const agent of AGENTS) {
+    out.push({
+      ...agent,
+      detected: Boolean(await commandExists(agent.bin))
+    });
+  }
+  return out;
+}
+var DOCKER_OLLAMA = "docker run -d --name pudu-ollama -p 11434:11434 -v ollama:/root/.ollama ollama/ollama";
+
+// src/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 args = ["launch", def.ollamaLaunch, "--model", decision.ollamaTag];
+  if (def.id === "openclaw" || def.id === "claude") args.push("--yes");
+  lines.push(`ollama ${args.join(" ")}`);
+  const launched = await runCommand("ollama", args, {
+    timeout: 0,
+    stdio: "inherit"
+  });
+  if (launched.exitCode !== 0) {
+    return {
+      ok: false,
+      log: `${lines.join("\n")}
+${launched.stderr || launched.stdout || t("launchExecFail")}`
+    };
+  }
+  return { ok: true, log: `${lines.join("\n")}
+${launched.stdout}`.trim() };
+}
+async function installWithBrew(kind) {
+  const { brewInstall } = await import("./brew-ZRR7D4XL.js");
+  if (kind === "ollama") {
+    const result = await brewInstall(["install", "ollama"]);
+    if (result.ok) {
+      void runCommand("ollama", ["serve"], { timeout: 4e3 });
+    }
+    return result;
+  }
+  return brewInstall(["install", "--cask", "lm-studio"]);
+}
+async function executeDockerOllama() {
+  const { brewInstallCask, dockerReady, startDockerDesktop, waitForDocker } = await import("./brew-ZRR7D4XL.js");
+  const notes = [];
+  if (!await dockerReady()) {
+    notes.push(t("dockerBrewInstall"));
+    const installed = await brewInstallCask("docker");
+    if (!installed.ok) {
+      return { ok: false, log: `${t("reqDocker")}
+${installed.log}` };
+    }
+    notes.push(t("dockerDesktopWait"));
+    await startDockerDesktop();
+    const up = await waitForDocker();
+    if (!up) return { ok: false, log: `${notes.join("\n")}
+${t("dockerRunFail")}` };
+  }
+  const start = await runCommand("docker", ["start", "pudu-ollama"], { timeout: 3e4 });
+  if (start.exitCode === 0) return { ok: true, log: t("dockerRunOk") };
+  const args = DOCKER_OLLAMA.split(" ").slice(1);
+  const result = await runCommand("docker", args, { timeout: 10 * 6e4 });
+  if (result.exitCode !== 0) {
+    return { ok: false, log: result.stderr || t("dockerRunFail") };
+  }
+  return { ok: true, log: t("dockerRunOk") };
+}
+
+// src/integrations/pull.ts
+var INSTALLABLE = ["S", "A", "B"];
+function canInstallGrade(grade) {
+  return Boolean(grade && INSTALLABLE.includes(grade));
+}
+async function pullOllamaModel(modelId, extraName) {
+  const tag = resolveOllamaTag(modelId, extraName);
+  if (!tag) {
+    return { ok: false, log: t("noOllamaTag", { model: extraName ?? modelId }), tag: modelId };
+  }
+  const result = await runCommand("ollama", ["pull", tag], { timeout: 30 * 6e4 });
+  if (result.exitCode !== 0) {
+    return { ok: false, log: result.stderr || t("launchPullFail"), tag };
+  }
+  return { ok: true, log: t("modelPulled", { model: tag }), tag };
+}
+
+// src/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/cli/color.ts
+var enabled = () => !process.env.NO_COLOR && process.stdout.isTTY;
+var wrap = (open, close = 39) => (text) => enabled() ? `\x1B[${open}m${text}\x1B[${close}m` : text;
+var cyan = wrap(36);
+var green = wrap(32);
+var yellow = wrap(33);
+var red = wrap(31);
+var magenta = wrap(35);
+var bold = wrap(1, 22);
+var dim = wrap(2, 22);
+function gradeAnsi(grade) {
+  if (grade === "S" || grade === "A") return green(grade);
+  if (grade === "B") return yellow(grade);
+  if (grade === "C") return magenta(grade);
+  if (grade === "D" || grade === "F") return red(grade);
+  return grade;
+}
+
+// src/cli/text.ts
+function hardwareText(session) {
+  const h = session.hardware;
+  const ram = formatBytes(h.memory.totalBytes, 0);
+  const avail = h.memory.availableBytes ? formatBytes(h.memory.availableBytes) : "N/A";
+  return [
+    bold(cyan(t("machine"))),
+    `  ${h.machineModel ?? t("unknownMachine")}`,
+    `  ${h.cpu.name ?? t("cpuNa")}`,
+    `  CPU           ${h.cpu.physicalCores ?? "N/A"} cores (${h.cpu.performanceCores ?? "?"}P / ${h.cpu.efficiencyCores ?? "?"}E)`,
+    `  GPU           ${h.gpu.name ?? "N/A"}`,
+    `  ${memoryLabel(h).padEnd(13)} ${ram}`,
+    `  Available     ${avail}`,
+    `  ${h.os}         ${h.osVersion ?? h.arch}`
+  ].join("\n");
+}
+function runtimesText(session) {
+  return [
+    bold(cyan(t("runtimes"))),
+    ...session.runtimes.map((r) => {
+      const mark = r.detected ? green("\u2713") : dim("\u25CB");
+      const state = r.detected ? green(r.version ?? t("detected")) : dim(t("notDetected"));
+      return `  ${mark} ${r.label.padEnd(14)} ${state}`;
+    })
+  ].join("\n");
+}
+function modelsText(session) {
+  const lines = [bold(cyan(t("installedModels"))), dim("MODEL                 INSTALLED   FIT       EST. SPEED     MEASURED")];
+  for (const row of session.rows) {
+    const 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(
+      `${green(row.local.name.padEnd(22))} \u2713           ${gradeAnsi(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 = [bold(cyan(t("recommended"))), dim(t("recommendedHint")), "", dim(t("credits")), ""];
+  for (const rec of session.recommendations) {
+    lines.push(
+      `${magenta(rec.useCase.padEnd(12))} ${rec.model.name.padEnd(22)} ${gradeAnsi(rec.grade)}  ${GRADE_MEANING[rec.grade]}  ~${na(rec.estimatedTokensPerSecond)} t/s est.`
+    );
+  }
+  lines.push("", bold(yellow(t("agentsTitle"))));
+  for (const agent of session.agents) {
+    lines.push(
+      `  ${agent.detected ? green("\u2713") : dim("\u25CB")} ${agent.label.padEnd(12)} ${agent.detected ? green(t("detected")) : dim(t("agentMissing"))}`
+    );
+  }
+  lines.push("", dim(t("recommendCliHint")));
+  return lines.join("\n");
+}
+function historyText(records) {
+  if (!records.length) return t("historyEmpty");
+  return records.map((r) => {
+    const gen = r.benchmark.generationTokensPerSecond;
+    return `${r.timestamp}  ${r.model.id.padEnd(18)}  ${gen ? formatTokensPerSec(gen) : "N/A"}  score ${r.score?.total ?? "N/A"}`;
+  }).join("\n");
+}
+function historyCsv(records) {
+  const header = "timestamp,model,prompt_tps,generation_tps,peak_memory_gb,avg_cpu,score";
+  const rows = records.map(
+    (r) => [
+      r.timestamp,
+      r.model.id,
+      r.benchmark.promptTokensPerSecond ?? "",
+      r.benchmark.generationTokensPerSecond ?? "",
+      r.resources.peakMemoryGb ?? "",
+      r.resources.avgCpuPercent ?? "",
+      r.score?.total ?? ""
+    ].join(",")
+  );
+  return [header, ...rows].join("\n");
+}
+function doctorText(session) {
+  const node = process.version.replace(/^v/, "");
+  const apple = session.hardware.cpu.appleSilicon ? `${session.hardware.cpu.appleSilicon.generation} ${session.hardware.cpu.appleSilicon.variant}` : "no";
+  const lines = [
+    t("doctorTitle"),
+    "",
+    `\u2713 Node.js       ${node}`,
+    `${session.hardware.cpu.appleSilicon ? "\u2713" : "\u25CB"} Apple Silicon ${apple}`,
+    `${session.hardware.gpu.metal ? "\u2713" : "\u25CB"} Metal`,
+    ...session.runtimes.map((r) => `${r.detected ? "\u2713" : "\u25CB"} ${r.label.padEnd(14)} ${r.version ?? ""}`.trimEnd()),
+    `${session.networkUsed ? "\u2713" : "\u25CB"} CanIRun.ai (midudev)`,
+    ...session.agents.map(
+      (a) => `${a.detected ? "\u2713" : "\u25CB"} ${a.label.padEnd(14)} ${a.detected ? t("detected") : a.launch}`
+    ),
+    ...session.runtimes.find((r) => r.id === "ollama")?.detected ? [] : [`\u25CB Ollama        ${t("reqOllama")}`],
+    ...session.runtimes.find((r) => r.id === "lmstudio")?.detected ? [] : [`\u25CB LM Studio     ${t("reqLmStudio")}`],
+    ...session.runtimes.find((r) => r.id === "docker")?.detected ? [`\u2713 Docker         ${t("dockerHint")}`] : [`\u25CB Docker        ${t("reqDocker")}`],
+    "",
+    session.llamaBench ? t("doctorReady", { count: session.models.filter((m) => m.artifactPath).length }) : t("doctorNoBench")
+  ];
+  return lines.join("\n");
+}
+function reportMarkdown(record) {
+  const machine = `${record.machine.cpu ?? "unknown"} / ${record.machine.memoryGb ?? "?"} GB`;
+  return `## ${t("reportTitle")}
+
+**Machine:** ${machine}
+**Model:** ${record.model.id}
+
+| Metric | Result |
+|---|---:|
+| Prompt processing | ${record.benchmark.promptTokensPerSecond ?? "N/A"} t/s |
+| Generation | ${record.benchmark.generationTokensPerSecond ?? "N/A"} t/s |
+| Peak memory | ${record.resources.peakMemoryGb ?? "N/A"} GB |
+| Average GPU | ${record.resources.avgGpuPercent ?? "N/A"}% |
+| Average power | ${record.resources.avgPackagePowerWatts ?? "N/A"} W |
+| Efficiency | ${record.resources.tokensPerSecondPerWatt ?? "N/A"} t/s/W |
+| ${t("scoreLabel")} | ${record.score?.total ?? "N/A"} / 100 |
+`;
+}
+function compareText(records) {
+  const latestByModel = /* @__PURE__ */ new Map();
+  for (const record of records) latestByModel.set(record.model.id, record);
+  const list = [...latestByModel.values()].slice(0, 4);
+  if (list.length < 2) return t("compareNeedTwo");
+  const names = list.map((r) => r.model.id);
+  const row = (label, pick) => `${label.padEnd(20)}${list.map((r) => pick(r).padStart(14)).join("")}`;
+  const winner = (metric, higher = true) => {
+    let best;
+    for (const r of list) {
+      const v = metric(r);
+      if (v === void 0) continue;
+      if (!best) best = r;
+      else {
+        const b = metric(best);
+        if (b === void 0) best = r;
+        else if (higher ? v > b : v < b) best = r;
+      }
+    }
+    return best?.model.id ?? "N/A";
+  };
+  return [
+    t("compareTitle"),
+    names.join(" vs "),
+    row("Generation t/s", (r) => formatNumber(r.benchmark.generationTokensPerSecond)),
+    row("Prompt t/s", (r) => formatNumber(r.benchmark.promptTokensPerSecond)),
+    row("Peak RAM", (r) => r.resources.peakMemoryGb ? `${r.resources.peakMemoryGb} GB` : "N/A"),
+    row("Avg CPU", (r) => r.resources.avgCpuPercent ? `${r.resources.avgCpuPercent}%` : "N/A"),
+    row("Power", (r) => r.resources.avgPackagePowerWatts ? `${r.resources.avgPackagePowerWatts} W` : "N/A"),
+    row("t/s/W", (r) => formatNumber(r.resources.tokensPerSecondPerWatt)),
+    "",
+    t("winner"),
+    `Speed       ${winner((r) => r.benchmark.generationTokensPerSecond)}`,
+    `Memory      ${winner((r) => r.resources.peakMemoryGb, false)}`,
+    `Efficiency  ${winner((r) => r.resources.tokensPerSecondPerWatt)}`,
+    t("qualityNote")
+  ].join("\n");
+}
+function resultText(record, assessment) {
+  return [
+    record.model.id,
+    "",
+    `Prompt processing       ${record.benchmark.promptTokensPerSecond ?? "N/A"} t/s`,
+    `Generation               ${record.benchmark.generationTokensPerSecond ?? "N/A"} t/s`,
+    `Peak memory               ${record.resources.peakMemoryGb ?? "N/A"} GB`,
+    `Average GPU                ${record.resources.avgGpuPercent ?? "N/A"} %`,
+    `Average CPU                ${record.resources.avgCpuPercent ?? "N/A"} %`,
+    `Average power              ${record.resources.avgPackagePowerWatts ?? "N/A"} W`,
+    `Efficiency                ${record.resources.tokensPerSecondPerWatt ?? "N/A"} t/s/W`,
+    "",
+    `${t("scoreLabel")}          ${record.score?.total ?? "N/A"}/100`,
+    "",
+    ...assessment.map((line) => `\u2713 ${line}`)
+  ].join("\n");
+}
+
+export {
+  bytesToGiB,
+  parseSizeToBytes,
+  formatBytes,
+  configPath,
+  canirunCachePath,
+  ensureStorage,
+  detectHardware,
+  idsLikelyMatch,
+  resolveOllamaTag,
+  localCompatibility,
+  listBenchmarks,
+  detectAgents,
+  runBenchmark,
+  WORK_KINDS,
+  parseAnswers,
+  planTasks,
+  tasksText,
+  decideLaunch,
+  decideAll,
+  launchText,
+  parseIntegration,
+  executeLaunch,
+  installWithBrew,
+  executeDockerOllama,
+  canInstallGrade,
+  pullOllamaModel,
+  memoryLabel,
+  GRADE_MEANING,
+  hardwareText,
+  runtimesText,
+  modelsText,
+  recommendText,
+  historyText,
+  historyCsv,
+  doctorText,
+  reportMarkdown,
+  compareText,
+  resultText
+};