@bendyline/gezel 0.1.0

package/dist/native/index.js

@@ -0,0 +1,1121 @@
+// src/native/llama-backend.ts
+import { execSync } from "child_process";
+import {
+  constants,
+  accessSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  writeFileSync
+} from "fs";
+import { dirname, join } from "path";
+import { arch as nodeArch, platform as nodePlatform } from "process";
+function resolveAvailableLlamaBinary(preferredBackend, resolveBinary, allowFallbacks, isUsable) {
+  const fallbackOrder = {
+    cuda: ["cuda", "vulkan", "cpu"],
+    vulkan: ["vulkan", "cpu"],
+    metal: ["metal", "cpu"],
+    cpu: ["cpu"]
+  };
+  const candidates = allowFallbacks ? fallbackOrder[preferredBackend] : [preferredBackend];
+  const skippedUnusable = [];
+  for (const backend of candidates) {
+    const path = resolveBinary(backend);
+    if (!path) continue;
+    if (allowFallbacks && isUsable && !isUsable(backend, path)) {
+      skippedUnusable.push(backend);
+      continue;
+    }
+    return {
+      backend,
+      path,
+      ...backend === preferredBackend ? {} : { fallbackFrom: preferredBackend },
+      ...skippedUnusable.length > 0 ? { skippedUnusable: [...skippedUnusable] } : {}
+    };
+  }
+  return null;
+}
+var PROBE_SCHEMA_VERSION = 1;
+function fileExistsDefault(path) {
+  try {
+    accessSync(path, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function anyExists(paths, probe) {
+  for (const p of paths) {
+    if (probe(p)) return p;
+  }
+  return null;
+}
+function commandOkDefault(cmd) {
+  try {
+    execSync(cmd, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readFileTextDefault(path) {
+  try {
+    return readFileSync(path, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function readDirDefault(path) {
+  try {
+    return readdirSync(path);
+  } catch {
+    return [];
+  }
+}
+function detectVendor(os, probeFile, readFileText, readDir) {
+  if (os === "linux") {
+    const found = /* @__PURE__ */ new Set();
+    for (const entry of readDir("/sys/class/drm")) {
+      if (!/^card\d+$/.test(entry)) continue;
+      const vid = readFileText(`/sys/class/drm/${entry}/device/vendor`)?.trim().toLowerCase();
+      if (vid === "0x1002") found.add("amd");
+      else if (vid === "0x10de") found.add("nvidia");
+      else if (vid === "0x8086") found.add("intel");
+    }
+    if (found.has("nvidia")) return "nvidia";
+    if (found.has("amd")) return "amd";
+    if (found.has("intel")) return "intel";
+    return void 0;
+  }
+  const sys32 = process.env.SYSTEMROOT ? join(process.env.SYSTEMROOT, "System32") : "C:\\Windows\\System32";
+  if (probeFile(join(sys32, "nvcuda.dll")) || probeFile(join(sys32, "nvapi64.dll"))) {
+    return "nvidia";
+  }
+  if (probeFile(join(sys32, "aticfx64.dll")) || probeFile(join(sys32, "amdxc64.dll")) || probeFile(join(sys32, "amdhip64.dll"))) {
+    return "amd";
+  }
+  if (probeFile(join(sys32, "igdumdim64.dll")) || probeFile(join(sys32, "igc64.dll"))) {
+    return "intel";
+  }
+  return void 0;
+}
+function detectLinuxOrWin(os, probeFile, probeCmd, readFileText, readDir) {
+  const vendorHint = detectVendor(os, probeFile, readFileText, readDir);
+  if (os === "linux") {
+    const libcuda = anyExists(
+      [
+        "/usr/lib/x86_64-linux-gnu/libcuda.so.1",
+        "/usr/lib/aarch64-linux-gnu/libcuda.so.1",
+        "/usr/lib64/libcuda.so.1",
+        "/usr/lib/libcuda.so.1",
+        "/lib/x86_64-linux-gnu/libcuda.so.1",
+        "/lib/aarch64-linux-gnu/libcuda.so.1"
+      ],
+      probeFile
+    );
+    if (libcuda) {
+      const smiOk = probeCmd("nvidia-smi -L");
+      return {
+        backend: "cuda",
+        reason: `found ${libcuda}${smiOk ? ", nvidia-smi ok" : ", nvidia-smi absent or failing (proceeding anyway)"}`,
+        vendorHint
+      };
+    }
+  } else {
+    const sys32 = process.env.SYSTEMROOT ? join(process.env.SYSTEMROOT, "System32") : "C:\\Windows\\System32";
+    const nvcuda = anyExists([join(sys32, "nvcuda.dll"), join(sys32, "nvml.dll")], probeFile);
+    if (nvcuda) {
+      return { backend: "cuda", reason: `found ${nvcuda}`, vendorHint };
+    }
+  }
+  if (os === "linux") {
+    const libvulkan = anyExists(
+      [
+        "/usr/lib/x86_64-linux-gnu/libvulkan.so.1",
+        "/usr/lib/aarch64-linux-gnu/libvulkan.so.1",
+        "/usr/lib64/libvulkan.so.1",
+        "/usr/lib/libvulkan.so.1"
+      ],
+      probeFile
+    );
+    if (libvulkan) {
+      return { backend: "vulkan", reason: `found ${libvulkan}`, vendorHint };
+    }
+  } else {
+    const sys32 = process.env.SYSTEMROOT ? join(process.env.SYSTEMROOT, "System32") : "C:\\Windows\\System32";
+    const vk = anyExists([join(sys32, "vulkan-1.dll")], probeFile);
+    if (vk) {
+      return { backend: "vulkan", reason: `found ${vk}`, vendorHint };
+    }
+  }
+  return { backend: "cpu", reason: "no CUDA driver and no Vulkan loader found", vendorHint };
+}
+function detectLlamaBackend(input) {
+  const probed = probeOrCached(input);
+  if (input.override && input.override !== "auto") {
+    return {
+      backend: input.override,
+      detectedBackend: probed.backend,
+      cached: probed.cached,
+      reason: `pinned by config.llamaCppBackendOverride=${input.override} (hardware probe: ${probed.reason})`,
+      probedAt: probed.probedAt,
+      ...probed.vendorHint ? { vendorHint: probed.vendorHint } : {}
+    };
+  }
+  return {
+    backend: probed.backend,
+    detectedBackend: probed.backend,
+    cached: probed.cached,
+    reason: probed.reason,
+    probedAt: probed.probedAt,
+    ...probed.vendorHint ? { vendorHint: probed.vendorHint } : {}
+  };
+}
+function probeOrCached(input) {
+  const probeFile = input.probe?.fileExists ?? fileExistsDefault;
+  const probeCmd = input.probe?.commandOk ?? commandOkDefault;
+  const probeReadFile = input.probe?.readFileText ?? readFileTextDefault;
+  const probeReadDir = input.probe?.readDir ?? readDirDefault;
+  const cachePath = join(input.home, "engines", "llama-cpp", "backend.json");
+  if (fileExistsDefault(cachePath)) {
+    try {
+      const cached = JSON.parse(readFileSync(cachePath, "utf8"));
+      const schemaOk = (cached.probeSchemaVersion ?? 0) >= PROBE_SCHEMA_VERSION;
+      if (cached.engineVersion === input.engineVersion && schemaOk) {
+        return {
+          backend: cached.backend,
+          cached: true,
+          reason: `cached: ${cached.reason}`,
+          probedAt: cached.probedAt,
+          ...cached.vendorHint ? { vendorHint: cached.vendorHint } : {}
+        };
+      }
+    } catch {
+    }
+  }
+  const plat = input.probe?.platform ?? nodePlatform;
+  const ar = input.probe?.arch ?? nodeArch;
+  let result;
+  if (plat === "darwin") {
+    if (ar === "arm64") {
+      result = { backend: "metal", reason: "Apple Silicon \u2014 Metal always available" };
+    } else {
+      result = { backend: "cpu", reason: "Intel Mac \u2014 no Metal path, using CPU" };
+    }
+  } else if (plat === "linux" && (ar === "x64" || ar === "arm64")) {
+    result = detectLinuxOrWin("linux", probeFile, probeCmd, probeReadFile, probeReadDir);
+  } else if (plat === "win32" && ar === "x64") {
+    result = detectLinuxOrWin("win32", probeFile, probeCmd, probeReadFile, probeReadDir);
+  } else {
+    result = { backend: "cpu", reason: `unsupported platform ${plat}/${ar} \u2014 CPU only` };
+  }
+  const probedAt = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    mkdirSync(dirname(cachePath), { recursive: true });
+    const payload = {
+      probeSchemaVersion: PROBE_SCHEMA_VERSION,
+      engineVersion: input.engineVersion,
+      backend: result.backend,
+      reason: result.reason,
+      probedAt,
+      ...result.vendorHint ? { vendorHint: result.vendorHint } : {}
+    };
+    writeFileSync(cachePath, JSON.stringify(payload, null, 2));
+  } catch {
+  }
+  return {
+    backend: result.backend,
+    cached: false,
+    reason: result.reason,
+    probedAt,
+    ...result.vendorHint ? { vendorHint: result.vendorHint } : {}
+  };
+}
+
+// src/native/llama-quarantine.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, statSync, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+var SCHEMA_VERSION = 1;
+function llamaQuarantinePath(home) {
+  return join2(home, "engines", "llama-cpp", "unusable.json");
+}
+function binaryFingerprint(path, io = {}) {
+  const statFile = io.statFile ?? ((p) => statSync(p));
+  try {
+    const info = statFile(path);
+    return `${info.size}:${Math.trunc(info.mtimeMs)}`;
+  } catch {
+    return null;
+  }
+}
+function readLlamaQuarantine(home, io = {}) {
+  const readFile = io.readFile ?? ((p) => readFileSync2(p, "utf8"));
+  try {
+    const parsed = JSON.parse(readFile(llamaQuarantinePath(home)));
+    if (parsed.schemaVersion !== SCHEMA_VERSION || !Array.isArray(parsed.entries)) return [];
+    return parsed.entries.filter(isEntry);
+  } catch {
+    return [];
+  }
+}
+function isBinaryQuarantined(entries, backend, binaryPath, io = {}) {
+  const entry = entries.find((e) => e.backend === backend);
+  if (!entry) return false;
+  const current = binaryFingerprint(binaryPath, io);
+  return current !== null && current === entry.fingerprint;
+}
+function recordLlamaQuarantine(home, input, io = {}) {
+  const fingerprint = binaryFingerprint(input.binaryPath, io);
+  if (!fingerprint) return null;
+  const now = io.now?.() ?? /* @__PURE__ */ new Date();
+  const entry = {
+    backend: input.backend,
+    fingerprint,
+    signal: input.signal,
+    reason: input.reason,
+    at: now.toISOString()
+  };
+  const kept = readLlamaQuarantine(home, io).filter((e) => e.backend !== input.backend);
+  const path = llamaQuarantinePath(home);
+  const mkdir = io.mkdir ?? ((p) => void mkdirSync2(p, { recursive: true }));
+  const writeFile = io.writeFile ?? ((p, data) => writeFileSync2(p, data, "utf8"));
+  const file = { schemaVersion: SCHEMA_VERSION, entries: [...kept, entry] };
+  mkdir(dirname2(path));
+  writeFile(path, `${JSON.stringify(file, null, 2)}
+`);
+  return entry;
+}
+function isEntry(value) {
+  if (value === null || typeof value !== "object") return false;
+  const e = value;
+  return typeof e.backend === "string" && typeof e.fingerprint === "string" && typeof e.signal === "string" && typeof e.reason === "string" && typeof e.at === "string";
+}
+
+// src/native/discover.ts
+import { existsSync } from "fs";
+import { join as join3 } from "path";
+
+// src/native/llama-engine-version.ts
+var LLAMA_ENGINE_VERSION = "b10353";
+
+// src/native/platform-key.ts
+function resolvePlatformKey(platform = process.platform, arch = process.arch) {
+  if (platform === "darwin") {
+    return arch === "arm64" ? "darwin-arm64" : "darwin-x64";
+  }
+  if (platform === "linux") {
+    if (arch === "x64") return "linux-x64";
+    if (arch === "arm64") return "linux-arm64";
+  }
+  if (platform === "win32" && arch === "x64") {
+    return "win32-x64";
+  }
+  return null;
+}
+
+// src/native/discover.ts
+function resolveNativeBinaryUnder(root, name, subdir, platform = process.platform, fileExists = existsSync) {
+  const ext = platform === "win32" ? ".exe" : "";
+  const candidates = name === "uv" ? [`uv${ext}`] : [`gezel-${name}${ext}`, `${name}${ext}`];
+  for (const file of candidates) {
+    const p = join3(root, subdir, file);
+    if (fileExists(p)) return p;
+  }
+  return null;
+}
+function discoverNativeBinaries(input) {
+  const log = input.logger;
+  const fileExists = input.fileExists ?? existsSync;
+  const platform = input.platform ?? process.platform;
+  const arch = input.arch ?? process.arch;
+  const dir = input.nativeBinDirOverride ?? process.env.GEZEL_NATIVE_BIN_DIR;
+  const binaries = [];
+  const result = { binaries };
+  const platformKey = resolvePlatformKey(platform, arch);
+  if (!platformKey) {
+    for (const name of [
+      "llama-server",
+      "ds4-server",
+      "sd-server",
+      "whisper-server",
+      "device-health",
+      "uv"
+    ]) {
+      binaries.push({ name, source: "no-platform-key" });
+    }
+    return result;
+  }
+  if (process.env.GEZEL_LLAMA_SERVER_BIN) {
+    binaries.push({
+      name: "llama-server",
+      source: "pre-set",
+      path: process.env.GEZEL_LLAMA_SERVER_BIN
+    });
+  } else {
+    const probe = detectLlamaBackend({
+      engineVersion: LLAMA_ENGINE_VERSION,
+      home: input.home,
+      ...input.llamaCppBackendOverride ? { override: input.llamaCppBackendOverride } : {},
+      ...input.llamaProbeOverride ? { probe: { ...input.llamaProbeOverride, platform, arch } } : { probe: { platform, arch } }
+    });
+    process.env.GEZEL_LLAMA_DETECTED_BACKEND = probe.detectedBackend;
+    if (probe.vendorHint) {
+      process.env.GEZEL_LLAMA_DETECTED_VENDOR = probe.vendorHint;
+    }
+    result.llamaBackend = {
+      backend: probe.backend,
+      detectedBackend: probe.detectedBackend,
+      reason: probe.reason,
+      cached: probe.cached,
+      ...probe.vendorHint ? { vendorHint: probe.vendorHint } : {}
+    };
+    if (!dir) {
+      binaries.push({ name: "llama-server", source: "no-native-bin-dir", variant: probe.backend });
+    } else {
+      const allowFallbacks = input.llamaCppBackendOverride === void 0 || input.llamaCppBackendOverride === "auto";
+      const quarantine = input.quarantine ?? readLlamaQuarantine(input.home);
+      const resolved = resolveAvailableLlamaBinary(
+        probe.backend,
+        (backend) => resolveNativeBinaryUnder(
+          dir,
+          "llama-server",
+          `${platformKey}-${backend}`,
+          platform,
+          fileExists
+        ) ?? // Variant-less fallback covers Mac's single Metal build and
+        // native trees staged before multi-variant packaging.
+        resolveNativeBinaryUnder(dir, "llama-server", platformKey, platform, fileExists),
+        allowFallbacks,
+        quarantine.length > 0 ? (backend, path) => !isBinaryQuarantined(quarantine, backend, path) : void 0
+      );
+      if (resolved) {
+        process.env.GEZEL_LLAMA_SERVER_BIN = resolved.path;
+        process.env.GEZEL_LLAMA_SERVER_BACKEND = resolved.backend;
+        for (const skipped of resolved.skippedUnusable ?? []) {
+          const entry = quarantine.find((e) => e.backend === skipped);
+          log?.warn?.(
+            `[native] llama-server ${skipped} build is quarantined on this machine (${entry?.signal ?? "crashed"} at ${entry?.at ?? "unknown time"}): ${entry?.reason ?? "crashed before becoming ready"}`
+          );
+        }
+        if (resolved.skippedUnusable?.length) {
+          result.llamaBackend.backend = resolved.backend;
+          result.llamaBackend.reason = `${probe.reason}; ${resolved.skippedUnusable.join(", ")} quarantined after crashing on this machine, using ${resolved.backend}`;
+          result.llamaBackend.quarantined = [...resolved.skippedUnusable];
+          process.env.GEZEL_LLAMA_QUARANTINED = resolved.skippedUnusable.join(",");
+        } else if (resolved.fallbackFrom) {
+          result.llamaBackend.backend = resolved.backend;
+          result.llamaBackend.reason = `${probe.reason}; no bundled ${resolved.fallbackFrom} binary, using ${resolved.backend}`;
+          log?.info?.(
+            `[native] no bundled llama-server for ${resolved.fallbackFrom}; using ${resolved.backend} fallback: ${resolved.path}`
+          );
+        }
+        binaries.push({
+          name: "llama-server",
+          source: "discovered",
+          path: resolved.path,
+          variant: resolved.backend
+        });
+        log?.info?.(
+          `[native] discovered llama-server (${resolved.backend}${probe.cached ? ", cached" : ""}): ${resolved.path}`
+        );
+      } else {
+        binaries.push({ name: "llama-server", source: "not-found", variant: probe.backend });
+        log?.warn?.(
+          `[native] no llama-server binary bundled for ${probe.backend} under ${dir} (probe: ${probe.reason})`
+        );
+      }
+    }
+  }
+  const subdirFor = (name) => name === "ds4-server" && platform === "linux" ? `${platformKey}-cuda` : platformKey;
+  for (const { name, envVar } of [
+    { name: "ds4-server", envVar: "GEZEL_DS4_SERVER_BIN" },
+    { name: "sd-server", envVar: "GEZEL_SD_SERVER_BIN" },
+    { name: "whisper-server", envVar: "GEZEL_WHISPER_SERVER_BIN" },
+    { name: "device-health", envVar: "GEZEL_DEVICE_HEALTH_BIN" },
+    { name: "uv", envVar: "GEZEL_UV_BIN" }
+  ]) {
+    if (process.env[envVar]) {
+      binaries.push({ name, source: "pre-set", path: process.env[envVar] });
+      continue;
+    }
+    if (!dir) {
+      binaries.push({ name, source: "no-native-bin-dir" });
+      continue;
+    }
+    const subdir = subdirFor(name);
+    const bin = resolveNativeBinaryUnder(dir, name, subdir, platform, fileExists) ?? (subdir === platformKey ? null : resolveNativeBinaryUnder(dir, name, platformKey, platform, fileExists));
+    if (bin) {
+      process.env[envVar] = bin;
+      binaries.push({ name, source: "discovered", path: bin });
+      log?.info?.(`[native] discovered ${name}: ${bin}`);
+    } else {
+      binaries.push({ name, source: "not-found" });
+    }
+  }
+  return result;
+}
+
+// src/native/console-detach.ts
+function windowsDetachedSpawnOptions(platform = process.platform) {
+  return platform === "win32" ? { detached: true } : {};
+}
+
+// src/native/device-health.ts
+import { execFile as nodeExecFile } from "child_process";
+
+// src/device-safety.ts
+var DEVICE_HARD_TEMPERATURE_C = 105;
+
+// src/native/device-health.ts
+var DEFAULT_DEVICE_SAFETY_POLICY = {
+  mode: "observe",
+  maxStartTemperatureC: 80,
+  resumeTemperatureC: 75,
+  minThermalMarginC: 8,
+  pollIntervalMs: 5e3,
+  maxWaitMs: 10 * 6e4,
+  consecutiveHealthySamples: 3,
+  onTelemetryFailure: "allow"
+};
+function envNumber(env, key) {
+  const raw = env[key]?.trim();
+  if (!raw) return void 0;
+  const value = Number(raw);
+  return Number.isFinite(value) ? value : void 0;
+}
+function resolveDeviceSafetyPolicy(input, env = process.env) {
+  const envMode = env.GEZEL_DEVICE_SAFETY_MODE?.trim().toLowerCase();
+  const mode = envMode === "off" || envMode === "observe" || envMode === "guard" ? envMode : input?.mode;
+  const envTelemetryFailure = env.GEZEL_DEVICE_SAFETY_TELEMETRY_FAILURE?.trim().toLowerCase();
+  const onTelemetryFailure = envTelemetryFailure === "allow" || envTelemetryFailure === "block" ? envTelemetryFailure : input?.onTelemetryFailure;
+  const resolved = {
+    mode: mode ?? DEFAULT_DEVICE_SAFETY_POLICY.mode,
+    maxStartTemperatureC: envNumber(env, "GEZEL_DEVICE_SAFETY_MAX_START_TEMP_C") ?? input?.maxStartTemperatureC ?? DEFAULT_DEVICE_SAFETY_POLICY.maxStartTemperatureC,
+    resumeTemperatureC: envNumber(env, "GEZEL_DEVICE_SAFETY_RESUME_TEMP_C") ?? input?.resumeTemperatureC ?? DEFAULT_DEVICE_SAFETY_POLICY.resumeTemperatureC,
+    minThermalMarginC: envNumber(env, "GEZEL_DEVICE_SAFETY_MIN_THERMAL_MARGIN_C") ?? input?.minThermalMarginC ?? DEFAULT_DEVICE_SAFETY_POLICY.minThermalMarginC,
+    pollIntervalMs: envNumber(env, "GEZEL_DEVICE_SAFETY_POLL_MS") ?? input?.pollIntervalMs ?? DEFAULT_DEVICE_SAFETY_POLICY.pollIntervalMs,
+    maxWaitMs: envNumber(env, "GEZEL_DEVICE_SAFETY_MAX_WAIT_MS") ?? input?.maxWaitMs ?? DEFAULT_DEVICE_SAFETY_POLICY.maxWaitMs,
+    consecutiveHealthySamples: envNumber(env, "GEZEL_DEVICE_SAFETY_HEALTHY_SAMPLES") ?? input?.consecutiveHealthySamples ?? DEFAULT_DEVICE_SAFETY_POLICY.consecutiveHealthySamples,
+    onTelemetryFailure: onTelemetryFailure ?? DEFAULT_DEVICE_SAFETY_POLICY.onTelemetryFailure
+  };
+  resolved.pollIntervalMs = Math.max(500, Math.min(6e4, resolved.pollIntervalMs));
+  resolved.maxWaitMs = Math.max(0, Math.min(36e5, resolved.maxWaitMs));
+  resolved.consecutiveHealthySamples = Math.max(
+    1,
+    Math.min(20, Math.trunc(resolved.consecutiveHealthySamples))
+  );
+  resolved.resumeTemperatureC = Math.min(
+    resolved.resumeTemperatureC,
+    resolved.maxStartTemperatureC
+  );
+  return resolved;
+}
+function parseNumber(raw) {
+  if (typeof raw === "number" && Number.isFinite(raw)) return raw;
+  if (typeof raw !== "string") return void 0;
+  const match = raw.replaceAll(",", "").match(/-?\d+(?:\.\d+)?/);
+  if (!match) return void 0;
+  const value = Number(match[0]);
+  return Number.isFinite(value) ? value : void 0;
+}
+function isActive(raw) {
+  if (typeof raw === "boolean") return raw;
+  if (typeof raw === "number") return raw !== 0;
+  if (typeof raw !== "string") return void 0;
+  const value = raw.trim().toLowerCase();
+  if (["active", "yes", "true", "1", "enabled"].includes(value)) return true;
+  if (["not active", "no", "false", "0", "disabled", "n/a"].includes(value)) return false;
+  return void 0;
+}
+function parseNvidiaSmiCsv(stdout) {
+  return stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).flatMap((line) => {
+    const fields = line.split(",").map((field) => field.trim());
+    if (fields.length < 10) return [];
+    const [
+      index,
+      name,
+      temperature,
+      thermalMargin,
+      utilization,
+      memoryUsed,
+      memoryTotal,
+      hwThermal,
+      swThermal,
+      powerBrake
+    ] = fields;
+    return [
+      {
+        vendor: "nvidia",
+        deviceId: index || "0",
+        ...name ? { name } : {},
+        ...parseNumber(temperature) !== void 0 ? { temperatureC: parseNumber(temperature) } : {},
+        ...parseNumber(thermalMargin) !== void 0 ? { thermalMarginC: parseNumber(thermalMargin) } : {},
+        ...parseNumber(utilization) !== void 0 ? { utilizationPercent: parseNumber(utilization) } : {},
+        ...parseNumber(memoryUsed) !== void 0 ? { memoryUsedMb: parseNumber(memoryUsed) } : {},
+        ...parseNumber(memoryTotal) !== void 0 ? { memoryTotalMb: parseNumber(memoryTotal) } : {},
+        thermalSlowdown: isActive(hwThermal) === true || isActive(swThermal) === true,
+        powerBrake: isActive(powerBrake) === true
+      }
+    ];
+  });
+}
+function flattenMetrics(value, path, out) {
+  if (Array.isArray(value)) {
+    value.forEach((entry, index) => flattenMetrics(entry, `${path}.${index}`, out));
+    return;
+  }
+  if (value && typeof value === "object") {
+    for (const [key, child] of Object.entries(value)) {
+      flattenMetrics(child, path ? `${path}.${key}` : key, out);
+    }
+    return;
+  }
+  out.push({ path: path.toLowerCase(), value });
+}
+function maxMetric(metrics, predicate) {
+  const values = metrics.filter((metric) => predicate(metric.path)).map((metric) => parseNumber(metric.value)).filter((value) => value !== void 0);
+  return values.length > 0 ? Math.max(...values) : void 0;
+}
+function parseAmdSmiJson(stdout, source = "amd-smi") {
+  let root;
+  try {
+    root = JSON.parse(stdout);
+  } catch {
+    return [];
+  }
+  const candidates = [];
+  if (Array.isArray(root)) {
+    root.forEach((value, index) => candidates.push({ id: String(index), value }));
+  } else if (root && typeof root === "object") {
+    const entries = Object.entries(root);
+    const deviceEntries = entries.filter(
+      ([key, value]) => value !== null && typeof value === "object" && /(?:^|[-_\s])(gpu|card|device)\s*\d*/i.test(key)
+    );
+    if (deviceEntries.length > 0) {
+      for (const [id, value] of deviceEntries) candidates.push({ id, value });
+    } else {
+      candidates.push({ id: "0", value: root });
+    }
+  }
+  return candidates.flatMap(({ id, value }) => {
+    const metrics = [];
+    flattenMetrics(value, "", metrics);
+    const temperatureC = maxMetric(
+      metrics,
+      (path) => /temp|temperature|junction|hotspot|edge/.test(path) && !/limit|threshold|critical|maximum|max_temp/.test(path)
+    );
+    const utilizationPercent = maxMetric(
+      metrics,
+      (path) => /gpu.*(?:use|util)|gfx.*(?:use|util|activity)|busy_percent|gpu%/.test(path)
+    );
+    const memoryUsedMb = maxMetric(
+      metrics,
+      (path) => /(?:vram|memory).*(?:used|usage_mb)/.test(path) && !/percent|%/.test(path)
+    );
+    const memoryTotalMb = maxMetric(
+      metrics,
+      (path) => /(?:vram|memory).*(?:total|size_mb)/.test(path)
+    );
+    const throttleMetrics = metrics.filter((metric) => /thrott|thermal.*slow/.test(metric.path));
+    const thermalSlowdown = throttleMetrics.some((metric) => isActive(metric.value) === true);
+    const hasTelemetry = temperatureC !== void 0 || utilizationPercent !== void 0 || memoryUsedMb !== void 0 || throttleMetrics.length > 0;
+    if (!hasTelemetry) return [];
+    return [
+      {
+        vendor: "amd",
+        deviceId: id,
+        name: source,
+        ...temperatureC !== void 0 ? { temperatureC } : {},
+        ...utilizationPercent !== void 0 ? { utilizationPercent } : {},
+        ...memoryUsedMb !== void 0 ? { memoryUsedMb } : {},
+        ...memoryTotalMb !== void 0 ? { memoryTotalMb } : {},
+        thermalSlowdown
+      }
+    ];
+  });
+}
+function optionalFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function parseDeviceHealthHelperJson(stdout) {
+  let raw;
+  try {
+    raw = JSON.parse(stdout);
+  } catch {
+    return null;
+  }
+  if (!raw || typeof raw !== "object") return null;
+  const root = raw;
+  if (root.schemaVersion !== 1 || !Array.isArray(root.readings)) return null;
+  const readings = [];
+  for (const entry of root.readings) {
+    if (!entry || typeof entry !== "object") return null;
+    const reading = entry;
+    if (!["nvidia", "amd", "apple", "generic"].includes(String(reading.vendor)) || typeof reading.deviceId !== "string") {
+      return null;
+    }
+    const normalized = {
+      vendor: reading.vendor,
+      deviceId: reading.deviceId
+    };
+    if (typeof reading.name === "string") normalized.name = reading.name;
+    const temperatureC = optionalFiniteNumber(reading.temperatureC);
+    const thermalMarginC = optionalFiniteNumber(reading.thermalMarginC);
+    const utilizationPercent = optionalFiniteNumber(reading.utilizationPercent);
+    const memoryUsedMb = optionalFiniteNumber(reading.memoryUsedMb);
+    const memoryTotalMb = optionalFiniteNumber(reading.memoryTotalMb);
+    if (temperatureC !== void 0) normalized.temperatureC = temperatureC;
+    if (thermalMarginC !== void 0) normalized.thermalMarginC = thermalMarginC;
+    if (utilizationPercent !== void 0) normalized.utilizationPercent = utilizationPercent;
+    if (memoryUsedMb !== void 0) normalized.memoryUsedMb = memoryUsedMb;
+    if (memoryTotalMb !== void 0) normalized.memoryTotalMb = memoryTotalMb;
+    if (typeof reading.thermalSlowdown === "boolean") {
+      normalized.thermalSlowdown = reading.thermalSlowdown;
+    }
+    if (typeof reading.powerBrake === "boolean") normalized.powerBrake = reading.powerBrake;
+    readings.push(normalized);
+  }
+  const processes = [];
+  if (root.processes !== void 0) {
+    if (!Array.isArray(root.processes)) return null;
+    for (const entry of root.processes) {
+      if (!entry || typeof entry !== "object") return null;
+      const process2 = entry;
+      const pid = optionalFiniteNumber(process2.pid);
+      const dedicatedBytes = optionalFiniteNumber(process2.dedicatedBytes);
+      const owner = String(process2.owner);
+      if (pid === void 0 || !Number.isInteger(pid) || pid <= 0 || dedicatedBytes === void 0 || dedicatedBytes < 0 || ![
+        "machine-engine",
+        "app-engine",
+        "development-engine",
+        "gezel-engine",
+        "external"
+      ].includes(owner)) {
+        return null;
+      }
+      processes.push({
+        pid,
+        ...typeof process2.name === "string" ? { name: process2.name } : {},
+        dedicatedBytes,
+        owner
+      });
+    }
+  }
+  const strings = (value) => Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+  return {
+    sample: {
+      sampledAt: typeof root.sampledAt === "string" && root.sampledAt.length > 0 ? root.sampledAt : (/* @__PURE__ */ new Date()).toISOString(),
+      sources: strings(root.sources),
+      readings,
+      ...processes.length > 0 ? { processes } : {},
+      errors: strings(root.errors)
+    },
+    diagnostics: strings(root.diagnostics)
+  };
+}
+var NVIDIA_QUERY = [
+  "index",
+  "name",
+  "temperature.gpu",
+  "temperature.gpu.tlimit",
+  "utilization.gpu",
+  "memory.used",
+  "memory.total",
+  "clocks_event_reasons.hw_thermal_slowdown",
+  "clocks_event_reasons.sw_thermal_slowdown",
+  "clocks_event_reasons.hw_power_brake_slowdown"
+].join(",");
+function defaultCommandRunner(command, args, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    nodeExecFile(
+      command,
+      args,
+      // nvidia-smi / amd-smi are console-subsystem, and the Session 0 service
+      // has no console for the loader to allocate from, so they start with
+      // DETACHED_PROCESS; `windowsHide` (CREATE_NO_WINDOW) still allocates
+      // one. When these probes fail the daemon sees no GPU at all and plans
+      // capacity against system RAM — the symptom that made a token-level
+      // spawn denial look like a GPU-detection bug.
+      { timeout: timeoutMs, ...windowsDetachedSpawnOptions() },
+      (error, stdout, stderr) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve({ stdout: String(stdout), stderr: String(stderr) });
+      }
+    );
+  });
+}
+function createSystemDeviceHealthProbe(opts = {}) {
+  const run = opts.commandRunner ?? defaultCommandRunner;
+  const timeoutMs = opts.timeoutMs ?? 5e3;
+  const helperPath = opts.helperPath === void 0 ? process.env.GEZEL_DEVICE_HEALTH_BIN : opts.helperPath;
+  return {
+    async sample() {
+      const readings = [];
+      const sources = [];
+      const errors = [];
+      let processes;
+      if (helperPath) {
+        try {
+          const result = await run(helperPath, ["sample", "--json"], timeoutMs);
+          const parsed = parseDeviceHealthHelperJson(result.stdout);
+          if (!parsed) {
+            errors.push("device-health helper: invalid JSON contract");
+          } else {
+            readings.push(...parsed.sample.readings);
+            sources.push(...parsed.sample.sources);
+            processes = parsed.sample.processes;
+            errors.push(...parsed.sample.errors.map((error) => `device-health helper: ${error}`));
+            if (parsed.sample.readings.length > 0) {
+              return {
+                sampledAt: parsed.sample.sampledAt,
+                sources,
+                readings,
+                ...processes ? { processes } : {},
+                errors
+              };
+            }
+            errors.push(
+              ...parsed.diagnostics.map((diagnostic) => `device-health helper: ${diagnostic}`)
+            );
+          }
+        } catch (error) {
+          errors.push(
+            `device-health helper: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      if (!opts.preferredVendor || opts.preferredVendor === "nvidia") {
+        try {
+          const result = await run(
+            "nvidia-smi",
+            [`--query-gpu=${NVIDIA_QUERY}`, "--format=csv,noheader,nounits"],
+            timeoutMs
+          );
+          const parsed = parseNvidiaSmiCsv(result.stdout);
+          if (parsed.length > 0) {
+            readings.push(...parsed);
+            sources.push("nvidia-smi");
+          }
+        } catch (error) {
+          errors.push(`nvidia-smi: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+      if (!opts.preferredVendor || opts.preferredVendor === "amd") {
+        let amdReadings = [];
+        try {
+          const result = await run(
+            "amd-smi",
+            ["metric", "--temperature", "--usage", "--mem-usage", "--violation", "--json"],
+            timeoutMs
+          );
+          amdReadings = parseAmdSmiJson(result.stdout, "amd-smi");
+          if (amdReadings.length > 0) sources.push("amd-smi");
+        } catch (error) {
+          errors.push(`amd-smi: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (amdReadings.length === 0) {
+          try {
+            const result = await run(
+              "rocm-smi",
+              ["--showtemp", "--showuse", "--showmemuse", "--json"],
+              timeoutMs
+            );
+            amdReadings = parseAmdSmiJson(result.stdout, "rocm-smi");
+            if (amdReadings.length > 0) sources.push("rocm-smi");
+          } catch (error) {
+            errors.push(`rocm-smi: ${error instanceof Error ? error.message : String(error)}`);
+          }
+        }
+        readings.push(...amdReadings);
+      }
+      return {
+        sampledAt: (/* @__PURE__ */ new Date()).toISOString(),
+        sources,
+        readings,
+        ...processes ? { processes } : {},
+        errors
+      };
+    }
+  };
+}
+function evaluateDeviceHealth(sample, policy, cooling = false) {
+  if (policy.mode === "off") {
+    return {
+      admissible: true,
+      hardBlocked: false,
+      telemetryAvailable: sample.readings.length > 0,
+      reasons: [],
+      summary: "device safety is off"
+    };
+  }
+  if (sample.readings.length === 0) {
+    const admissible = policy.onTelemetryFailure === "allow";
+    const reasons2 = admissible ? [] : ["device telemetry unavailable"];
+    return {
+      admissible,
+      hardBlocked: false,
+      telemetryAvailable: false,
+      reasons: reasons2,
+      summary: admissible ? "device telemetry unavailable; policy allows work" : "device telemetry unavailable; policy blocks work"
+    };
+  }
+  const reasons = [];
+  let hardBlocked = false;
+  const temperatureLimit = cooling ? policy.resumeTemperatureC : policy.maxStartTemperatureC;
+  for (const reading of sample.readings) {
+    const label = `${reading.vendor}:${reading.name ?? reading.deviceId}`;
+    if (reading.temperatureC !== void 0 && reading.temperatureC > temperatureLimit) {
+      reasons.push(
+        `${label} temperature ${reading.temperatureC}C exceeds ${temperatureLimit}C ${cooling ? "resume" : "start"} limit`
+      );
+    }
+    if (reading.temperatureC !== void 0 && reading.temperatureC > DEVICE_HARD_TEMPERATURE_C) {
+      hardBlocked = true;
+      reasons.push(
+        `${label} temperature ${reading.temperatureC}C exceeds hard ${DEVICE_HARD_TEMPERATURE_C}C safety limit`
+      );
+    }
+    if (reading.thermalMarginC !== void 0 && reading.thermalMarginC < policy.minThermalMarginC) {
+      reasons.push(
+        `${label} thermal margin ${reading.thermalMarginC}C is below ${policy.minThermalMarginC}C`
+      );
+    }
+    if (reading.thermalSlowdown) reasons.push(`${label} reports thermal slowdown`);
+    if (reading.powerBrake) reasons.push(`${label} reports hardware power braking`);
+  }
+  return {
+    admissible: reasons.length === 0,
+    hardBlocked,
+    telemetryAvailable: true,
+    reasons,
+    summary: reasons.length === 0 ? `device telemetry healthy (${sample.sources.join(", ") || "unknown source"})` : reasons.join("; ")
+  };
+}
+var DeviceHealthGate = class {
+  policy;
+  probe;
+  log;
+  sleep;
+  now;
+  cooling = false;
+  pendingAdmission;
+  pendingSample;
+  lastSample;
+  lastSampleAt = 0;
+  admissionBlocked = false;
+  lastUnavailableDiagnostic = "";
+  constructor(opts) {
+    this.probe = opts.probe;
+    this.policy = resolveDeviceSafetyPolicy(opts.policy);
+    this.log = opts.log ?? (() => {
+    });
+    this.sleep = opts.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    this.now = opts.now ?? Date.now;
+  }
+  setPolicy(policy) {
+    this.policy = resolveDeviceSafetyPolicy(policy);
+    if (this.policy.mode === "off") this.cooling = false;
+  }
+  getPolicy() {
+    return { ...this.policy };
+  }
+  /**
+   * Return a cached-or-fresh normalized snapshot for status surfaces. The
+   * cache keeps a UI polling every few seconds from spawning overlapping SMI
+   * processes, while admission can still force a fresh sample after it ages.
+   */
+  async status(maxAgeMs = 5e3) {
+    const sample = this.lastSample && this.now() - this.lastSampleAt <= maxAgeMs ? this.lastSample : await this.sampleDevice();
+    if (this.policy.mode === "off") {
+      return {
+        state: "off",
+        mode: "off",
+        sampledAt: sample.sampledAt,
+        sources: [...sample.sources],
+        readings: sample.readings.map((reading) => ({ ...reading })),
+        ...sample.processes ? { processes: sample.processes.map((process2) => ({ ...process2 })) } : {},
+        reasons: [],
+        summary: "Device safety is off"
+      };
+    }
+    const decision = evaluateDeviceHealth(sample, this.policy, this.cooling);
+    const state = !decision.telemetryAvailable ? "unavailable" : decision.admissible ? "healthy" : decision.hardBlocked || this.admissionBlocked ? "blocked" : this.cooling ? "cooling" : "warm";
+    return {
+      state,
+      mode: this.policy.mode,
+      sampledAt: sample.sampledAt,
+      sources: [...sample.sources],
+      readings: sample.readings.map((reading) => ({ ...reading })),
+      ...sample.processes ? { processes: sample.processes.map((process2) => ({ ...process2 })) } : {},
+      reasons: [...decision.reasons],
+      summary: decision.summary
+    };
+  }
+  async admit(context) {
+    if (this.policy.mode === "off") {
+      return {
+        admissible: true,
+        hardBlocked: false,
+        telemetryAvailable: false,
+        reasons: [],
+        summary: "device safety is off"
+      };
+    }
+    if (!this.pendingAdmission) {
+      this.pendingAdmission = this.runAdmission(context).finally(() => {
+        this.pendingAdmission = void 0;
+      });
+    }
+    return this.pendingAdmission;
+  }
+  async runAdmission(context) {
+    const startedAt = this.now();
+    let healthySamples = 0;
+    let loggedWaiting = false;
+    while (true) {
+      const sample = await this.sampleDevice();
+      const decision = evaluateDeviceHealth(sample, this.policy, this.cooling);
+      if (this.policy.mode === "observe") {
+        if (!decision.hardBlocked) {
+          if (!decision.admissible || !decision.telemetryAvailable) {
+            this.log(`[device-health] observe ${context}: ${decision.summary}`);
+          }
+          if (this.cooling) {
+            this.log(
+              `[device-health] ${context}: temperature returned to ${DEVICE_HARD_TEMPERATURE_C}C or below; admitting work`
+            );
+          }
+          this.cooling = false;
+          this.admissionBlocked = false;
+          return { ...decision, admissible: true };
+        }
+        healthySamples = 0;
+        this.cooling = true;
+        if (!loggedWaiting) {
+          this.log(`[device-health] ${context}: hard temperature gate \u2014 ${decision.summary}`);
+          loggedWaiting = true;
+        }
+      } else if (decision.admissible) {
+        healthySamples += 1;
+        const required = this.cooling ? this.policy.consecutiveHealthySamples : 1;
+        if (healthySamples >= required) {
+          if (this.cooling || loggedWaiting) {
+            this.log(
+              `[device-health] ${context}: healthy for ${healthySamples} sample(s); admitting work`
+            );
+          }
+          this.cooling = false;
+          this.admissionBlocked = false;
+          return decision;
+        }
+      } else {
+        healthySamples = 0;
+        this.cooling = true;
+        if (!loggedWaiting) {
+          this.log(`[device-health] ${context}: cooling before admission \u2014 ${decision.summary}`);
+          loggedWaiting = true;
+        }
+      }
+      const elapsed = this.now() - startedAt;
+      if (elapsed >= this.policy.maxWaitMs) {
+        this.admissionBlocked = true;
+        throw new Error(
+          `[device-health] ${context} blocked after ${elapsed}ms: ${decision.summary}`
+        );
+      }
+      await this.sleep(Math.min(this.policy.pollIntervalMs, this.policy.maxWaitMs - elapsed));
+    }
+  }
+  async sampleDevice() {
+    if (!this.pendingSample) {
+      this.pendingSample = this.probe.sample().catch((error) => ({
+        sampledAt: (/* @__PURE__ */ new Date()).toISOString(),
+        sources: [],
+        readings: [],
+        errors: [error instanceof Error ? error.message : String(error)]
+      })).then((sample) => {
+        const diagnostic = sample.readings.length === 0 ? sample.errors.join("; ") : "";
+        if (diagnostic && diagnostic !== this.lastUnavailableDiagnostic) {
+          this.log(`[device-health] telemetry unavailable: ${diagnostic}`);
+        }
+        this.lastUnavailableDiagnostic = diagnostic;
+        this.lastSample = sample;
+        this.lastSampleAt = this.now();
+        return sample;
+      }).finally(() => {
+        this.pendingSample = void 0;
+      });
+    }
+    return this.pendingSample;
+  }
+};
+
+// src/native/gpu-panic.ts
+import { readFileSync as readFileSync3, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { homedir } from "os";
+import { join as join4 } from "path";
+var PANIC_DIRS = [
+  "/Library/Logs/DiagnosticReports",
+  join4(homedir(), "Library", "Logs", "DiagnosticReports")
+];
+var GPU_PANIC_RE = /IOGPUMemory|IOAccelerator|AGXAccelerator|AGXG\d|completeMemory\(\)\s+prepare\s+count\s+underflow|IOGPUFamily/i;
+function findRecentGpuPanics(opts = {}) {
+  const dirs = opts.dirs ?? (process.platform === "darwin" ? PANIC_DIRS : []);
+  const withinMs = opts.withinMs ?? 24 * 60 * 60 * 1e3;
+  const now = opts.now ?? Date.now();
+  const out = [];
+  for (const dir of dirs) {
+    let names;
+    try {
+      names = readdirSync2(dir).filter((f) => f.endsWith(".panic") || f.endsWith(".ips"));
+    } catch {
+      continue;
+    }
+    for (const name of names) {
+      const path = join4(dir, name);
+      let mtimeMs;
+      try {
+        mtimeMs = statSync2(path).mtimeMs;
+      } catch {
+        continue;
+      }
+      if (now - mtimeMs > withinMs) continue;
+      let text;
+      try {
+        text = readFileSync3(path, "utf8").slice(0, 16384);
+      } catch {
+        continue;
+      }
+      const m = GPU_PANIC_RE.exec(text);
+      if (m) out.push({ file: path, when: new Date(mtimeMs), signature: m[0] });
+    }
+  }
+  return out.sort((a, b) => b.when.getTime() - a.when.getTime());
+}
+export {
+  DEFAULT_DEVICE_SAFETY_POLICY,
+  DEVICE_HARD_TEMPERATURE_C,
+  DeviceHealthGate,
+  GPU_PANIC_RE,
+  LLAMA_ENGINE_VERSION,
+  binaryFingerprint,
+  createSystemDeviceHealthProbe,
+  detectLlamaBackend,
+  discoverNativeBinaries,
+  evaluateDeviceHealth,
+  findRecentGpuPanics,
+  isBinaryQuarantined,
+  llamaQuarantinePath,
+  parseAmdSmiJson,
+  parseNvidiaSmiCsv,
+  readLlamaQuarantine,
+  recordLlamaQuarantine,
+  resolveAvailableLlamaBinary,
+  resolveDeviceSafetyPolicy,
+  resolveNativeBinaryUnder,
+  resolvePlatformKey,
+  windowsDetachedSpawnOptions
+};