preppergpt 0.1.1 → 0.1.3

package/README.md

@@ -1,13 +1,20 @@
 # PrepperGPT
 
-PrepperGPT packages a local-first ChatGPT-like experience for Linux machines.
-It uses upstream OpenWebUI for the app shell and adds a hardware detector,
-model planner, Docker Compose runtime, local sidecars, and a practical
-PrepperGPT field-kit theme.
-
-The first release targets Linux with NVIDIA GPUs first, with CPU fallback where
-possible. It is an online installer: model and container downloads require a
-working network during setup.
+PrepperGPT packages a local-first ChatGPT-like experience for post-apocalyptic
+or long-duration outage scenarios where hosted AI services are unavailable. It
+uses upstream OpenWebUI for the app shell and adds a hardware detector, model
+planner, Docker Compose runtime, local sidecars, and a practical PrepperGPT
+field-kit theme.
+
+PrepperGPT supports Linux first, including NVIDIA CUDA GPUs, Linux AMD ROCm
+GPUs, and CPU fallback where possible. Windows users should install and run it
+inside WSL2; native Windows installs are intentionally rejected until the native
+runtime path is reliable. It is an online installer: model and container
+downloads require a working network during setup.
+
+PrepperGPT optimizes for survivability over cloud-like latency. On very large
+local models, very low tokens/sec is acceptable because the alternative in the
+target scenario is no assistant at all.
 
 ## Install
 
@@ -35,6 +42,9 @@ node bin/preppergpt.js install --profile balanced
 node bin/preppergpt.js start
 ```
 
+Windows users should install Ubuntu in WSL2, enable Docker Desktop's WSL
+integration, and run the npm or GitHub install commands inside the WSL2 shell.
+
 Other profiles:
 
 ```bash
@@ -68,9 +78,11 @@ preppergpt bundle whisper
 ## Profiles
 
 - `intelligence`: chooses the strongest local reasoning route that fits the
-  machine, preferring GLM 5.2 Q4 and long-context coding routes when available.
+  machine, preferring GLM 5.2 Q8 on enterprise hardware, then GLM 5.2 Q4, then
+  long-context coding routes when available.
 - `speed`: chooses smaller GPU-friendly routes and makes low-latency chat the
-  default.
+  default. NVIDIA hosts use CUDA container access; Linux AMD hosts use the
+  Ollama ROCm image and ROCm device mounts when ROCm is detected.
 - `balanced`: uses the local auto-router as the default and keeps reasoning,
   coding, research, vision, image, and STT routes additive.
 
@@ -85,10 +97,18 @@ by default and mounted into OpenWebUI, so speech-to-text works from local files
 after setup.
 
 Some other routes can be pulled by the runtime, while very large routes such as
-GLM 5.2 Q4 and Flux weights are marked as manual or external in
+GLM 5.2 Q8/Q4 and Flux weights are marked as manual or external in
 `profiles/models.json`. `preppergpt doctor` reports which selected routes still
 need local files or endpoints.
 
+AMD acceleration requires a Linux ROCm host with `rocm-smi` or `rocminfo`
+available. AMD cards detected without ROCm stay on CPU-compatible routes and
+receive a doctor warning instead of a broken GPU configuration.
+
+The GLM 5.2 Q8 route is intended for an enterprise/off-grid bunker-class host:
+large RAM, fast NVMe, and patience for slow local generation when no hosted
+service remains available.
+
 ## Publishing
 
 The package is designed to be published as:

package/compose/preppergpt.yaml

@@ -27,8 +27,8 @@ services:
       ENABLE_OLLAMA_API: "True"
       OLLAMA_BASE_URLS: "${OLLAMA_BASE_URL:-http://127.0.0.1:11434}"
       ENABLE_OPENAI_API: "True"
-      OPENAI_API_BASE_URLS: "${SLOCODE_BASE_URL:-http://127.0.0.1:11438/v1};${GLM52_BASE_URL:-http://127.0.0.1:11441/v1};http://127.0.0.1:18041/v1;http://127.0.0.1:18043/v1;http://127.0.0.1:18044/v1"
-      OPENAI_API_KEYS: "slopcode;glm52;deep-research;local-agent;local-vision"
+      OPENAI_API_BASE_URLS: "${GLM52_Q8_BASE_URL:-http://127.0.0.1:11446/v1};${SLOCODE_BASE_URL:-http://127.0.0.1:11438/v1};${GLM52_BASE_URL:-http://127.0.0.1:11441/v1};http://127.0.0.1:18041/v1;http://127.0.0.1:18043/v1;http://127.0.0.1:18044/v1"
+      OPENAI_API_KEYS: "glm52-q8;slopcode;glm52;deep-research;local-agent;local-vision"
       ENABLE_DIRECT_CONNECTIONS: "True"
       DEFAULT_MODELS: "${PREPPERGPT_DEFAULT_MODEL:-local-chatgpt-auto}"
       MODEL_ORDER_LIST: "${PREPPERGPT_MODEL_ORDER_LIST:-[\"local-chatgpt-auto\"]}"
@@ -88,7 +88,7 @@ services:
       PORT: "${PREPPERGPT_PORT:-8080}"
 
   ollama:
-    image: ollama/ollama:latest
+    image: ${OLLAMA_IMAGE:-ollama/ollama:latest}
     container_name: preppergpt-ollama
     restart: unless-stopped
     network_mode: host
@@ -149,8 +149,8 @@ services:
       DEEP_RESEARCH_PORT: "18041"
       DEEP_RESEARCH_PUBLIC_BASE_URL: "http://127.0.0.1:18041"
       DEEP_RESEARCH_MODEL_ID: "deep-research-glm52"
-      DEEP_RESEARCH_MODEL: "${DEEP_RESEARCH_MODEL:-glm52-q4-local}"
-      DEEP_RESEARCH_GLM_BASE_URL: "${GLM52_BASE_URL:-http://127.0.0.1:11441/v1}"
+      DEEP_RESEARCH_MODEL: "${PREPPERGPT_GLM_MODEL:-glm52-q4-local}"
+      DEEP_RESEARCH_GLM_BASE_URL: "${PREPPERGPT_GLM_BASE_URL:-http://127.0.0.1:11441/v1}"
       DEEP_RESEARCH_SEARXNG_URL: "http://127.0.0.1:18080/search"
       DEEP_RESEARCH_TIKA_URL: "http://127.0.0.1:9998/tika"
       DEEP_RESEARCH_LOCAL_APP_CONNECTOR_URL: "http://127.0.0.1:18042"
@@ -187,16 +187,13 @@ services:
     network_mode: host
     volumes:
       - ${PREPPERGPT_DATA_DIR:?set PREPPERGPT_DATA_DIR}/local-agent:/data
-      - /tmp/.X11-unix:/tmp/.X11-unix:rw
-      - ${XDG_RUNTIME_DIR:-/run/user/1000}:${XDG_RUNTIME_DIR:-/run/user/1000}:rw
-      - ${XAUTHORITY:-/tmp/.preppergpt-missing-xauthority}:/tmp/.Xauthority:ro
     environment:
       LOCAL_AGENT_HOST: "127.0.0.1"
       LOCAL_AGENT_PORT: "18043"
       LOCAL_AGENT_PUBLIC_BASE_URL: "http://127.0.0.1:18043"
       LOCAL_AGENT_MODEL_ID: "local-agent-glm52"
-      LOCAL_AGENT_GLM_MODEL: "glm52-q4-local"
-      LOCAL_AGENT_GLM_BASE_URL: "${GLM52_BASE_URL:-http://127.0.0.1:11441/v1}"
+      LOCAL_AGENT_GLM_MODEL: "${PREPPERGPT_GLM_MODEL:-glm52-q4-local}"
+      LOCAL_AGENT_GLM_BASE_URL: "${PREPPERGPT_GLM_BASE_URL:-http://127.0.0.1:11441/v1}"
       LOCAL_AGENT_AUTO_ROUTER_MODEL_ID: "local-auto-router"
       LOCAL_AGENT_AUTO_ROUTER_FAST_MODEL: "gemma4:12b-256k-gpu"
       LOCAL_AGENT_AUTO_ROUTER_FAST_BASE_URL: "http://127.0.0.1:11434/v1"
@@ -210,7 +207,7 @@ services:
       LOCAL_AGENT_TIKA_URL: "http://127.0.0.1:9998/tika"
       LOCAL_AGENT_SCHEDULER_URL: "http://127.0.0.1:18042"
       LOCAL_AGENT_PLAYWRIGHT_WS_URL: "ws://127.0.0.1:18045"
-      LOCAL_AGENT_DESKTOP_ENABLED: "${LOCAL_AGENT_DESKTOP_ENABLED:-1}"
+      LOCAL_AGENT_DESKTOP_ENABLED: "${LOCAL_AGENT_DESKTOP_ENABLED:-0}"
       DISPLAY: "${DISPLAY:-}"
       WAYLAND_DISPLAY: "${WAYLAND_DISPLAY:-}"
       XDG_RUNTIME_DIR: "${XDG_RUNTIME_DIR:-/run/user/1000}"

package/docs/hardware.md

@@ -1,15 +1,40 @@
 # Hardware Guide
 
-PrepperGPT works best on Linux with an NVIDIA GPU and enough NVMe space for
-model weights.
+PrepperGPT works best on Linux with a supported GPU and enough NVMe space for
+model weights. NVIDIA CUDA is supported, Linux AMD ROCm is supported when
+`rocm-smi` or `rocminfo` is available, and CPU fallback remains available for
+smaller routes. Windows users should run PrepperGPT inside WSL2; native Windows
+installs are rejected with WSL2 guidance. It is designed for post-apocalyptic or
+long-duration outage scenarios, so the high-end GLM tiers deliberately favor
+local availability and answer quality over hosted-service latency.
 
 Recommended starting points:
 
 - Speed profile: 16 GB RAM, 8-12 GB VRAM, 40 GB free disk.
 - Balanced profile: 32-64 GB RAM, 12-24 GB VRAM, 120 GB free disk.
+- Linux AMD ROCm profile: 32-128 GB RAM, 12-24+ GB AMD VRAM, ROCm tools
+  installed, and Docker access to `/dev/kfd` and `/dev/dri`.
 - Intelligence profile: 96 GB RAM or more, fast NVMe, and hundreds of GB free
   for GLM 5.2 Q4 or similar large weights.
+- Enterprise 8-bit GLM tier: 256 GB RAM or more, 48-80 GB VRAM preferred,
+  and 1.5-2 TB of fast NVMe for GLM 5.2 Q8 plus working/cache room.
 
 The installer reserves about 15-20% VRAM headroom when deciding whether a model
 fits. If a large manual model is selected, `preppergpt doctor` explains the
 endpoint or file path that must be provided.
+
+Very low tokens/sec is acceptable for the GLM 5.2 Q8 tier because that tier is
+for situations where there is no cloud model to fall back to.
+
+## Hardware Matrix
+
+| Tier | Typical specs | PrepperGPT routes |
+| --- | --- | --- |
+| Basic CPU laptop | 16 GB RAM, no GPU, 80 GB disk | `local-chatgpt-auto`, `llama3.1:8b`, `local-vision-moondream2`, bundled Whisper |
+| Mid NVIDIA | 64 GB RAM, 12 GB usable VRAM, 250 GB disk | Gemma fast lane, Qwen coder fallback, local vision, bundled Whisper |
+| Mid AMD ROCm | 64 GB RAM, 12-24 GB usable AMD VRAM, ROCm on Linux, 250 GB disk | Ollama ROCm Gemma fast lane, Qwen coder fallback, local vision through Ollama, bundled Whisper |
+| AMD without ROCm | 32-64 GB RAM, AMD GPU detected, no ROCm tools | CPU-compatible routes plus a doctor warning to install ROCm for acceleration |
+| Windows WSL2 | 32+ GB RAM, Docker Desktop WSL integration, WSL2 Ubuntu | Linux-style install inside WSL2; native Windows install is rejected |
+| High NVIDIA | 128 GB RAM, 24 GB VRAM, 750 GB NVMe | GLM 5.2 Q4 configured, Slopcode/Qwen configured, Gemma fast lane, Flux configured |
+| Full PrepperGPT rig | 128+ GB RAM, 24+ GB VRAM, 1 TB NVMe, GLM/Slopcode/Flux files present | GLM 5.2 Q4 primary, Slopcode coding, Gemma fast lane, Deep Research, Agent, Vision, Flux, Whisper |
+| Enterprise 8-bit GLM rig | 256+ GB RAM, 48-80+ GB VRAM preferred, 1.5-2 TB fast NVMe | `glm52-q8-local` primary for Max Intelligence, `glm52-q4-local` fallback, Slopcode/Qwen coding, Gemma fast lane, full sidecar stack |

package/docs/model-sources.md

@@ -2,11 +2,13 @@
 
 PrepperGPT separates routing from model licensing and distribution.
 
-- Ollama models are pulled by the local Ollama runtime when available.
+- Ollama models are pulled by the local Ollama runtime when available. NVIDIA
+  hosts use the standard Ollama image; Linux AMD ROCm hosts use
+  `ollama/ollama:rocm` with `/dev/kfd` and `/dev/dri` exposed.
 - Whisper Base STT is installer-cached from `Systran/faster-whisper-base`
   under the local PrepperGPT model directory and mounted into OpenWebUI.
 - Hugging Face vision models are downloaded by the local vision sidecar.
-- Very large GLM, Slopcode, and Flux assets are marked as manual or external
+- Very large GLM Q8/Q4, Slopcode, and Flux assets are marked as manual or external
   until a license-compatible public download source is configured.
 
 Manual routes are still added to OpenWebUI. They become live when their local

package/docs/preppergpt-local-parity-map.md

@@ -1,10 +1,12 @@
 # PrepperGPT Local Parity Map
 
-PrepperGPT packages the local ChatGPT-like stack around OpenWebUI:
+PrepperGPT packages the local ChatGPT-like stack around OpenWebUI for resilient
+local use when hosted AI services are unavailable:
 
 - OpenWebUI UI at `http://127.0.0.1:8080`
 - Ollama fast local models at `http://127.0.0.1:11434`
-- Optional GLM 5.2 route at `http://127.0.0.1:11441/v1`
+- Optional GLM 5.2 Q8 route at `http://127.0.0.1:11446/v1`
+- Optional GLM 5.2 Q4 route at `http://127.0.0.1:11441/v1`
 - Optional Slopcode/Qwen route at `http://127.0.0.1:11438/v1`
 - Deep research sidecar at `http://127.0.0.1:18041/v1`
 - Local scheduler connector at `http://127.0.0.1:18042`
@@ -12,5 +14,9 @@ PrepperGPT packages the local ChatGPT-like stack around OpenWebUI:
 - Local vision sidecar at `http://127.0.0.1:18044/v1`
 - SearXNG, Tika, Jupyter, and ComfyUI support services
 
+Hardware support is additive: Linux NVIDIA uses CUDA container access, Linux AMD
+uses ROCm when available, CPU fallback remains available, and Windows support is
+through WSL2 rather than native Windows.
+
 The local goal is functional local parity for common ChatGPT workflows, not
 hosted frontier-model quality or cloud account continuity.

package/installer/cli.mjs

@@ -2,12 +2,12 @@ import fs from "node:fs";
 import http from "node:http";
 import { ensureWhisperBundle, modelDirs, whisperBundleStatus } from "./lib/bundles.mjs";
 import { detectMachine } from "./lib/detect.mjs";
-import { buildPlan, normalizeProfile } from "./lib/planner.mjs";
+import { buildPlan, installSupportError, normalizeProfile } from "./lib/planner.mjs";
 import { packageRoot, runtimePaths } from "./lib/paths.mjs";
 import { renderInstall } from "./lib/render.mjs";
 import { commandResult, parseArgs, readJson, shellQuote } from "./lib/util.mjs";
 
-const VERSION = "0.1.1";
+const VERSION = "0.1.3";
 
 function usage() {
   return `PrepperGPT ${VERSION}
@@ -34,6 +34,22 @@ function profileFrom(flags) {
   return normalizeProfile(flags.profile || flags.mode || "balanced");
 }
 
+function requiredToolStatuses(detection) {
+  return {
+    docker: Boolean(detection.tools?.docker),
+    dockerCompose: Boolean(detection.tools?.dockerCompose),
+    curl: Boolean(detection.tools?.curl),
+    "python3 or python": Boolean(detection.tools?.python3 || detection.tools?.python)
+  };
+}
+
+function assertSupportedInstall(detection) {
+  const message = installSupportError(detection);
+  if (message) {
+    throw new Error(message);
+  }
+}
+
 function composeArgs(paths) {
   return ["compose", "--env-file", paths.envFile, "-f", `${packageRoot}/compose/preppergpt.yaml`, "-f", paths.generatedCompose];
 }
@@ -88,19 +104,20 @@ async function commandDetect(flags) {
     printJson(detection);
     return;
   }
-  console.log(`Host: ${detection.hostname} (${detection.platform}/${detection.arch})`);
+  console.log(`Host: ${detection.hostname} (${detection.platformKind || detection.platform}/${detection.arch})`);
   console.log(`CPU: ${detection.cpu.cores} cores, ${detection.cpu.model}`);
   console.log(`RAM: ${detection.memory.totalGb} GB total, ${detection.memory.freeGb} GB free`);
   const bestDisk = detection.disks[0];
   console.log(`Disk: ${bestDisk ? `${bestDisk.freeGb.toFixed(1)} GB free at ${bestDisk.mount}` : "not detected"}`);
   if (detection.gpus.length) {
     for (const gpu of detection.gpus) {
-      console.log(`GPU ${gpu.index}: ${gpu.name}, ${gpu.totalVramGb} GB VRAM, ${gpu.freeVramGb} GB free`);
+      const memory = gpu.totalVramGb ? `${gpu.totalVramGb} GB VRAM, ${gpu.freeVramGb ?? "unknown"} GB free` : "VRAM unknown";
+      console.log(`GPU ${gpu.index}: ${gpu.vendor}/${gpu.runtime || "unknown"} ${gpu.name}, ${memory}`);
     }
   } else {
-    console.log("GPU: no NVIDIA GPU detected");
+    console.log("GPU: no supported GPU detected");
   }
-  const missing = Object.entries(detection.tools).filter(([, present]) => !present).map(([tool]) => tool);
+  const missing = Object.entries(requiredToolStatuses(detection)).filter(([, present]) => !present).map(([tool]) => tool);
   console.log(`Tools: ${missing.length ? `missing ${missing.join(", ")}` : "all required tools present"}`);
 }
 
@@ -117,6 +134,7 @@ async function commandPlan(flags) {
 async function commandInstall(flags) {
   const home = flags.home;
   const detection = await detectMachine();
+  assertSupportedInstall(detection);
   const plan = buildPlan(detection, profileFrom(flags));
   if (flags.dry_run) {
     printPlan(plan);
@@ -140,6 +158,7 @@ async function commandInstall(flags) {
 async function commandSwitchProfile(flags) {
   const paths = runtimePaths(flags.home);
   const detection = await detectMachine();
+  assertSupportedInstall(detection);
   const plan = buildPlan(detection, profileFrom(flags));
   renderInstall(plan, detection, { home: paths.root });
   console.log(`Switched PrepperGPT to ${plan.profile}.`);
@@ -199,9 +218,23 @@ async function commandDoctor(flags) {
   const plan = buildPlan(detection, profileFrom(flags));
   printPlan(plan);
   console.log("\nDoctor:");
-  const requiredTools = ["docker", "dockerCompose", "curl", "python3"];
-  for (const tool of requiredTools) {
-    console.log(`  ${tool}: ${detection.tools[tool] ? "ok" : "missing"}`);
+  const supportError = installSupportError(detection);
+  if (supportError) {
+    console.log(`  platform: unsupported (${supportError})`);
+  } else {
+    console.log(`  platform: ok (${detection.platformKind || detection.platform})`);
+  }
+  for (const [tool, present] of Object.entries(requiredToolStatuses(detection))) {
+    console.log(`  ${tool}: ${present ? "ok" : "missing"}`);
+  }
+  const amdGpu = detection.gpus.some((gpu) => gpu.vendor === "amd");
+  const nvidiaGpu = detection.gpus.some((gpu) => gpu.vendor === "nvidia");
+  if (nvidiaGpu) {
+    console.log(`  nvidia cuda: ${detection.tools.nvidiaSmi ? "ok" : "missing nvidia-smi"}`);
+  }
+  if (amdGpu) {
+    const rocmReady = detection.tools.rocmSmi || detection.tools.rocminfo;
+    console.log(`  amd rocm: ${rocmReady ? "ok" : "missing rocm-smi or rocminfo"}`);
   }
   for (const [port, entry] of Object.entries(detection.ports)) {
     if (!entry.free) {

package/installer/lib/detect.mjs

@@ -6,6 +6,31 @@ import { commandExists, commandResult, gb } from "./util.mjs";
 
 const DEFAULT_PORTS = [8080, 11434, 11438, 11441, 18041, 18042, 18043, 18044, 18045, 18080, 8188, 8888, 9998];
 
+function readFileMaybe(file) {
+  try {
+    return fs.readFileSync(file, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+export function detectPlatformKind() {
+  if (process.platform === "win32") {
+    return "windows-native";
+  }
+  if (process.platform === "darwin") {
+    return "macos";
+  }
+  if (process.platform !== "linux") {
+    return "unknown";
+  }
+  const release = `${readFileMaybe("/proc/sys/kernel/osrelease")}\n${readFileMaybe("/proc/version")}`.toLowerCase();
+  if (process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP || release.includes("microsoft") || release.includes("wsl")) {
+    return "wsl2";
+  }
+  return "linux";
+}
+
 function parseDf(target) {
   const result = commandResult("df", ["-Pk", target], { timeoutMs: 5000 });
   if (!result.ok) {
@@ -47,7 +72,57 @@ function candidateDiskPaths() {
   });
 }
 
-function detectGpus() {
+function usableVram(totalVramGb) {
+  return Math.round(totalVramGb * 0.82 * 10) / 10;
+}
+
+function normalizeGb(value) {
+  const number = Number(value);
+  return Number.isFinite(number) ? Math.round(number * 10) / 10 : null;
+}
+
+function bytesToGb(value) {
+  const number = Number(value);
+  return Number.isFinite(number) ? normalizeGb(number / 1024 ** 3) : null;
+}
+
+function memoryToGb(value, fallbackUnit = "bytes") {
+  if (value === null || value === undefined) {
+    return null;
+  }
+  const text = String(value).trim();
+  const matches = [...text.matchAll(/(\d+(?:\.\d+)?)/g)];
+  const number = Number(matches.at(-1)?.[1]);
+  if (!Number.isFinite(number)) {
+    return null;
+  }
+  const lower = text.toLowerCase();
+  if (/(gib|gb)/.test(lower)) {
+    return normalizeGb(number);
+  }
+  if (/(mib|mb)/.test(lower)) {
+    return normalizeGb(number / 1024);
+  }
+  if (/(kib|kb)/.test(lower)) {
+    return normalizeGb(number / 1024 / 1024);
+  }
+  if (/\(b\)|bytes?/.test(lower) || number > 1024 ** 3) {
+    return bytesToGb(number);
+  }
+  if (fallbackUnit === "mib" || number > 1024) {
+    return normalizeGb(number / 1024);
+  }
+  if (fallbackUnit === "bytes") {
+    return bytesToGb(number);
+  }
+  return normalizeGb(number);
+}
+
+function bestMatchingKey(record, patterns) {
+  return Object.keys(record).find((key) => patterns.some((pattern) => pattern.test(key)));
+}
+
+function detectNvidiaGpus() {
   if (!commandExists("nvidia-smi")) {
     return [];
   }
@@ -66,16 +141,171 @@ function detectGpus() {
       return {
         index,
         vendor: "nvidia",
+        runtime: "cuda",
         name,
-        totalVramGb: Math.round((Number(totalMiB) / 1024) * 10) / 10,
-        freeVramGb: Math.round((Number(freeMiB) / 1024) * 10) / 10,
-        usableVramGb: Math.round((Number(totalMiB) / 1024) * 0.82 * 10) / 10,
+        totalVramGb: normalizeGb(Number(totalMiB) / 1024),
+        freeVramGb: normalizeGb(Number(freeMiB) / 1024),
+        usableVramGb: usableVram(Number(totalMiB) / 1024),
         driver
       };
     })
     .filter((gpu) => gpu.name && Number.isFinite(gpu.totalVramGb));
 }
 
+function detectAmdRocmSmiGpus() {
+  if (!commandExists("rocm-smi")) {
+    return [];
+  }
+  const jsonResult = commandResult("rocm-smi", [
+    "--showproductname",
+    "--showmeminfo",
+    "vram",
+    "--showdriverversion",
+    "--json"
+  ]);
+  if (jsonResult.ok) {
+    try {
+      const parsed = JSON.parse(jsonResult.stdout);
+      return Object.entries(parsed)
+        .filter(([id, record]) => /^card\d+/i.test(id) && record && typeof record === "object")
+        .map(([id, record], index) => {
+          const totalKey = bestMatchingKey(record, [/vram.*total/i, /total.*memory/i]);
+          const usedKey = bestMatchingKey(record, [/vram.*used/i, /used.*memory/i]);
+          const nameKey = bestMatchingKey(record, [/product.*name/i, /card.*series/i, /marketing.*name/i]);
+          const driverKey = bestMatchingKey(record, [/driver/i]);
+          const totalVramGb = memoryToGb(record[totalKey]);
+          const usedVramGb = memoryToGb(record[usedKey]) || 0;
+          const freeVramGb = totalVramGb === null ? null : normalizeGb(Math.max(totalVramGb - usedVramGb, 0));
+          return {
+            index,
+            vendor: "amd",
+            runtime: "rocm",
+            name: String(record[nameKey] || id),
+            totalVramGb,
+            freeVramGb,
+            usableVramGb: totalVramGb === null ? null : usableVram(totalVramGb),
+            driver: String(record[driverKey] || "")
+          };
+        })
+        .filter((gpu) => gpu.name);
+    } catch {
+      // Fall through to text parsing.
+    }
+  }
+
+  const textResult = commandResult("rocm-smi", ["--showproductname", "--showmeminfo", "vram", "--showdriverversion"]);
+  if (!textResult.ok) {
+    return [];
+  }
+  const cards = new Map();
+  for (const line of textResult.stdout.split(/\n/)) {
+    const match = line.match(/(card\d+)\s*[:\t ]+(.*)$/i);
+    if (!match) {
+      continue;
+    }
+    const [, id, value] = match;
+    const record = cards.get(id) || {};
+    if (/product|series|marketing/i.test(value)) {
+      record.name = value.split(/[:=]/).at(-1)?.trim() || record.name;
+    }
+    if (/total.*vram|vram.*total/i.test(value)) {
+      record.totalVramGb = memoryToGb(value);
+    }
+    if (/used.*vram|vram.*used/i.test(value)) {
+      record.usedVramGb = memoryToGb(value);
+    }
+    if (/driver/i.test(value)) {
+      record.driver = value.split(/[:=]/).at(-1)?.trim();
+    }
+    cards.set(id, record);
+  }
+  return [...cards.entries()].map(([id, record], index) => {
+    const totalVramGb = record.totalVramGb ?? null;
+    const freeVramGb =
+      totalVramGb === null ? null : normalizeGb(Math.max(totalVramGb - (record.usedVramGb || 0), 0));
+    return {
+      index,
+      vendor: "amd",
+      runtime: "rocm",
+      name: record.name || id,
+      totalVramGb,
+      freeVramGb,
+      usableVramGb: totalVramGb === null ? null : usableVram(totalVramGb),
+      driver: record.driver || ""
+    };
+  });
+}
+
+function detectAmdRocinfoGpus() {
+  if (!commandExists("rocminfo")) {
+    return [];
+  }
+  const result = commandResult("rocminfo", [], { timeoutMs: 8000 });
+  if (!result.ok) {
+    return [];
+  }
+  const names = [];
+  for (const line of result.stdout.split(/\n/)) {
+    const match = line.match(/^\s*(?:Marketing Name|Name):\s*(.+)$/);
+    if (match && /amd|radeon|instinct|gfx/i.test(match[1])) {
+      names.push(match[1].trim());
+    }
+  }
+  return [...new Set(names)].map((name, index) => ({
+    index,
+    vendor: "amd",
+    runtime: "rocm",
+    name,
+    totalVramGb: null,
+    freeVramGb: null,
+    usableVramGb: null,
+    driver: ""
+  }));
+}
+
+function detectAmdPciGpus() {
+  if (!commandExists("lspci")) {
+    return [];
+  }
+  const result = commandResult("lspci", ["-mm"], { timeoutMs: 5000 });
+  if (!result.ok) {
+    return [];
+  }
+  return result.stdout
+    .split(/\n/)
+    .filter((line) => /(VGA compatible controller|3D controller|Display controller)/i.test(line) && /AMD|ATI|Radeon/i.test(line))
+    .map((line, index) => ({
+      index,
+      vendor: "amd",
+      runtime: "none",
+      name: line.replace(/^\S+\s+/, "").replaceAll('"', "").trim() || "AMD GPU",
+      totalVramGb: null,
+      freeVramGb: null,
+      usableVramGb: null,
+      driver: ""
+    }));
+}
+
+function dedupeGpus(gpus) {
+  const seen = new Set();
+  return gpus.filter((gpu) => {
+    const key = `${gpu.vendor}:${gpu.name}:${gpu.totalVramGb ?? "unknown"}`;
+    if (seen.has(key)) {
+      return false;
+    }
+    seen.add(key);
+    return true;
+  });
+}
+
+function detectGpus() {
+  const nvidia = detectNvidiaGpus();
+  const amdRocm = detectAmdRocmSmiGpus();
+  const amdFallback = amdRocm.length ? [] : detectAmdRocinfoGpus();
+  const amdPci = amdRocm.length || amdFallback.length ? [] : detectAmdPciGpus();
+  return dedupeGpus([...nvidia, ...amdRocm, ...amdFallback, ...amdPci]);
+}
+
 async function portFree(port) {
   return new Promise((resolve) => {
     const server = net.createServer();
@@ -93,6 +323,7 @@ async function detectPorts(ports = DEFAULT_PORTS) {
 }
 
 export async function detectMachine(options = {}) {
+  const platformKind = detectPlatformKind();
   const disks = candidateDiskPaths()
     .map(parseDf)
     .filter(Boolean)
@@ -104,12 +335,17 @@ export async function detectMachine(options = {}) {
     tmux: commandExists("tmux"),
     curl: commandExists("curl"),
     python3: commandExists("python3"),
+    python: commandExists("python"),
     git: commandExists("git"),
-    nvidiaSmi: commandExists("nvidia-smi")
+    nvidiaSmi: commandExists("nvidia-smi"),
+    rocmSmi: commandExists("rocm-smi"),
+    rocminfo: commandExists("rocminfo")
   };
   return {
     generatedAt: new Date().toISOString(),
     platform: process.platform,
+    platformKind,
+    isWsl2: platformKind === "wsl2",
     arch: process.arch,
     hostname: os.hostname(),
     cpu: {

package/installer/lib/planner.mjs

@@ -23,18 +23,57 @@ function bestDisk(detection) {
   return detection.disks?.[0] || { freeGb: 0, isNvme: false, path: "" };
 }
 
-function bestGpu(detection) {
-  return [...(detection.gpus || [])].sort((a, b) => b.usableVramGb - a.usableVramGb)[0] || null;
+function detectedPlatformKind(detection) {
+  if (detection.platformKind) {
+    return detection.platformKind;
+  }
+  if (detection.platform === "win32") {
+    return "windows-native";
+  }
+  if (detection.platform === "darwin") {
+    return "macos";
+  }
+  return detection.platform || "unknown";
+}
+
+function bestGpu(detection, vendors = null) {
+  const allowed = vendors ? new Set(vendors) : null;
+  return [...(detection.gpus || [])]
+    .filter((gpu) => !allowed || allowed.has(gpu.vendor))
+    .sort((a, b) => (b.usableVramGb || 0) - (a.usableVramGb || 0))[0] || null;
+}
+
+function gpuVendorLabel(vendors) {
+  if (!vendors?.length) {
+    return "supported";
+  }
+  return vendors.map((vendor) => (vendor === "nvidia" ? "NVIDIA" : vendor === "amd" ? "AMD" : vendor)).join("/");
+}
+
+function hasRocmRuntime(detection) {
+  return Boolean(detection.tools?.rocmSmi || detection.tools?.rocminfo);
+}
+
+export function installSupportError(detection) {
+  if (detectedPlatformKind(detection) === "windows-native") {
+    return "Native Windows install is not supported yet. Install PrepperGPT inside WSL2 so Docker, Linux paths, and local model services use the supported Linux runtime.";
+  }
+  return null;
 }
 
 function requirementFailures(model, detection) {
   const requires = model.requires || {};
   const disk = bestDisk(detection);
-  const gpu = bestGpu(detection);
+  const platformKind = detectedPlatformKind(detection);
+  const gpuVendors = requires.gpuVendors || null;
+  const gpu = bestGpu(detection, gpuVendors);
   const failures = [];
   if (requires.platforms && !requires.platforms.includes(detection.platform)) {
     failures.push(`requires platform ${requires.platforms.join(", ")}`);
   }
+  if (requires.platformKinds && !requires.platformKinds.includes(platformKind)) {
+    failures.push(`requires platform kind ${requires.platformKinds.join(", ")}`);
+  }
   if (requires.minRamGb && detection.memory.totalGb < requires.minRamGb) {
     failures.push(`requires ${requires.minRamGb} GB RAM`);
   }
@@ -44,11 +83,22 @@ function requirementFailures(model, detection) {
   if (requires.nvme && disk.freeGb >= (requires.diskGb || 0) && !disk.isNvme) {
     failures.push("strongly prefers NVMe for acceptable load time");
   }
+  if (requires.gpuVendors && detection.gpus?.length && !gpu) {
+    failures.push(`requires ${gpuVendorLabel(requires.gpuVendors)} GPU`);
+  }
   if (requires.gpu && !gpu) {
-    failures.push("requires NVIDIA GPU");
+    failures.push(`requires ${gpuVendorLabel(requires.gpuVendors)} GPU`);
   }
   if (requires.minVramGb && (!gpu || gpu.usableVramGb < requires.minVramGb)) {
-    failures.push(`requires about ${requires.minVramGb} GB usable VRAM`);
+    failures.push(`requires ${gpuVendorLabel(requires.gpuVendors)} GPU with about ${requires.minVramGb} GB usable VRAM`);
+  }
+  if (requires.requiresRocm && gpu?.vendor === "amd") {
+    if (platformKind !== "linux") {
+      failures.push("requires a Linux ROCm host for AMD GPU acceleration");
+    }
+    if (gpu.runtime !== "rocm" || !hasRocmRuntime(detection)) {
+      failures.push("requires ROCm runtime tools for AMD GPU acceleration");
+    }
   }
   return failures;
 }
@@ -62,7 +112,9 @@ function chooseFirst(candidates, models, detection) {
       continue;
     }
     const failures = requirementFailures(model, detection);
-    if (failures.length === 0 || model.source?.type === "manual" || model.source?.type === "external") {
+    const canUseExternalFallback =
+      ["manual", "external"].includes(model.source?.type) && !model.source?.requiresHardwareFit;
+    if (failures.length === 0 || canUseExternalFallback) {
       return { model, skipped };
     }
     skipped.push({ id, reasons: failures });
@@ -91,8 +143,9 @@ export function buildPlan(detection, requestedProfile = "balanced", catalog = lo
     }
   }
 
+  const defaultModel = selected.chat?.id || priorities.defaultModel;
   const routeIds = unique([
-    priorities.defaultModel,
+    defaultModel,
     selected.chat?.id,
     selected.fast?.id,
     selected.reasoning?.id,
@@ -113,9 +166,16 @@ export function buildPlan(detection, requestedProfile = "balanced", catalog = lo
     }));
 
   const warnings = [];
+  const installError = installSupportError(detection);
+  if (installError) {
+    warnings.push(installError);
+  }
   const missingTools = Object.entries(detection.tools || {})
-    .filter(([tool, present]) => ["docker", "dockerCompose", "curl", "python3"].includes(tool) && !present)
+    .filter(([tool, present]) => ["docker", "dockerCompose", "curl"].includes(tool) && !present)
     .map(([tool]) => tool);
+  if (!detection.tools?.python3 && !detection.tools?.python) {
+    missingTools.push("python3 or python");
+  }
   if (missingTools.length) {
     warnings.push(`Missing required tools: ${missingTools.join(", ")}`);
   }
@@ -125,8 +185,18 @@ export function buildPlan(detection, requestedProfile = "balanced", catalog = lo
   if (occupiedPorts.length) {
     warnings.push(`Ports already in use: ${occupiedPorts.join(", ")}`);
   }
-  if (!detection.gpus?.length) {
-    warnings.push("No NVIDIA GPU detected; CPU fallback will be much slower.");
+  const acceleratedGpu = (detection.gpus || []).find(
+    (gpu) => gpu.vendor === "nvidia" || (gpu.vendor === "amd" && gpu.runtime === "rocm" && detectedPlatformKind(detection) === "linux")
+  );
+  if (!acceleratedGpu) {
+    warnings.push("No supported GPU acceleration detected; CPU fallback will be much slower.");
+  }
+  const amdWithoutRocm = (detection.gpus || []).some((gpu) => gpu.vendor === "amd" && gpu.runtime !== "rocm");
+  if (amdWithoutRocm) {
+    warnings.push("AMD GPU detected without ROCm; install ROCm on Linux to enable AMD acceleration.");
+  }
+  if ((detection.gpus || []).some((gpu) => gpu.vendor === "amd") && detectedPlatformKind(detection) === "wsl2") {
+    warnings.push("AMD GPU acceleration is supported on Linux ROCm hosts; WSL2 installs will use CPU fallback unless an external AMD endpoint is provided.");
   }
   if (manualAssets.length) {
     warnings.push("Some selected high-quality routes need manual model files or already-running external endpoints.");
@@ -136,7 +206,7 @@ export function buildPlan(detection, requestedProfile = "balanced", catalog = lo
     generatedAt: new Date().toISOString(),
     profile,
     profileLabel: priorities.label,
-    defaultModel: priorities.defaultModel,
+    defaultModel,
     routeIds,
     selected,
     skipped,
@@ -144,7 +214,7 @@ export function buildPlan(detection, requestedProfile = "balanced", catalog = lo
     estimates: estimatePlan(profile, selected),
     env: {
       PREPPERGPT_PROFILE: profile,
-      PREPPERGPT_DEFAULT_MODEL: priorities.defaultModel,
+      PREPPERGPT_DEFAULT_MODEL: defaultModel,
       PREPPERGPT_MODEL_ORDER_LIST: JSON.stringify(routeIds)
     },
     warnings

package/installer/lib/render.mjs

@@ -9,10 +9,44 @@ function secret(bytes = 24) {
   return crypto.randomBytes(bytes).toString("hex");
 }
 
+function platformKind(detection) {
+  return detection.platformKind || (detection.platform === "win32" ? "windows-native" : detection.platform || "unknown");
+}
+
+function primaryAccelerator(detection) {
+  const gpus = detection.gpus || [];
+  const nvidia = gpus.find((gpu) => gpu.vendor === "nvidia");
+  if (nvidia) {
+    return { vendor: "nvidia", runtime: "cuda" };
+  }
+  const amdRocm = gpus.find((gpu) => gpu.vendor === "amd" && gpu.runtime === "rocm");
+  if (amdRocm && platformKind(detection) === "linux") {
+    return { vendor: "amd", runtime: "rocm" };
+  }
+  return { vendor: "cpu", runtime: "cpu" };
+}
+
+function desktopIntegrationEnabled(detection) {
+  const explicit = String(process.env.LOCAL_AGENT_DESKTOP_ENABLED || "").toLowerCase();
+  if (["0", "false", "no", "off"].includes(explicit)) {
+    return false;
+  }
+  const kind = platformKind(detection);
+  const platformSupportsDesktop = kind === "linux" || kind === "wsl2";
+  const hasDisplay = Boolean(process.env.DISPLAY || process.env.WAYLAND_DISPLAY);
+  return platformSupportsDesktop && hasDisplay && explicit !== "0";
+}
+
 function envFile(plan, paths, detection) {
   const dataDir = process.env.PREPPERGPT_DATA_DIR || paths.dataDir;
   const modelsDir = process.env.PREPPERGPT_MODELS_DIR || `${dataDir}/models`;
   const whisperHostDir = path.join(modelsDir, "whisper", "base");
+  const accelerator = primaryAccelerator(detection);
+  const selectedReasoningModel = plan.selected?.reasoning?.id || "glm52-q4-local";
+  const selectedGlmBaseUrl =
+    selectedReasoningModel === "glm52-q8-local"
+      ? process.env.GLM52_Q8_BASE_URL || "http://127.0.0.1:11446/v1"
+      : process.env.GLM52_BASE_URL || "http://127.0.0.1:11441/v1";
   const adminPassword = process.env.PREPPERGPT_ADMIN_PASSWORD || secret(18);
   const jupyterToken = process.env.JUPYTER_TOKEN || secret(18);
   const searxngSecret = process.env.SEARXNG_SECRET_KEY || secret(24);
@@ -26,7 +60,12 @@ function envFile(plan, paths, detection) {
     PREPPERGPT_PORT: process.env.PREPPERGPT_PORT || "8080",
     PREPPERGPT_DEFAULT_MODEL: plan.defaultModel,
     PREPPERGPT_MODEL_ORDER_LIST: JSON.stringify(plan.routeIds),
-    PREPPERGPT_DOCKER_GPUS: detection.gpus?.length ? "all" : "",
+    PREPPERGPT_GLM_MODEL: selectedReasoningModel,
+    PREPPERGPT_GLM_BASE_URL: selectedGlmBaseUrl,
+    PREPPERGPT_GPU_VENDOR: accelerator.vendor,
+    PREPPERGPT_ACCELERATOR: accelerator.runtime,
+    PREPPERGPT_DOCKER_GPUS: accelerator.vendor === "nvidia" ? "all" : "",
+    OLLAMA_IMAGE: accelerator.vendor === "amd" ? "ollama/ollama:rocm" : "ollama/ollama:latest",
     WEBUI_NAME: "PrepperGPT",
     WEBUI_ADMIN_EMAIL: process.env.WEBUI_ADMIN_EMAIL || "admin@preppergpt.local",
     WEBUI_ADMIN_PASSWORD: adminPassword,
@@ -35,6 +74,7 @@ function envFile(plan, paths, detection) {
     JUPYTER_TOKEN: jupyterToken,
     SEARXNG_SECRET_KEY: searxngSecret,
     GLM52_BASE_URL: process.env.GLM52_BASE_URL || "http://127.0.0.1:11441/v1",
+    GLM52_Q8_BASE_URL: process.env.GLM52_Q8_BASE_URL || "http://127.0.0.1:11446/v1",
     SLOCODE_BASE_URL: process.env.SLOCODE_BASE_URL || "http://127.0.0.1:11438/v1",
     OLLAMA_BASE_URL: process.env.OLLAMA_BASE_URL || "http://127.0.0.1:11434"
   };
@@ -45,13 +85,38 @@ function envFile(plan, paths, detection) {
 
 function generatedCompose(plan, detection) {
   const modelOrder = JSON.stringify(plan.routeIds);
-  const gpuBlock = detection.gpus?.length
-    ? [
+  const accelerator = primaryAccelerator(detection);
+  const gpuBlock =
+    accelerator.vendor === "nvidia"
+      ? [
         "  ollama:",
         "    gpus: all",
         "  local-vision:",
         "    gpus: all"
       ]
+      : accelerator.vendor === "amd"
+        ? [
+            "  ollama:",
+            "    devices:",
+            "      - /dev/kfd:/dev/kfd",
+            "      - /dev/dri:/dev/dri",
+            "    group_add:",
+            "      - video",
+            "      - render",
+            "    security_opt:",
+            "      - seccomp=unconfined"
+          ]
+        : [];
+  const desktopBlock = desktopIntegrationEnabled(detection)
+    ? [
+        "  local-agent:",
+        "    environment:",
+        "      LOCAL_AGENT_DESKTOP_ENABLED: \"1\"",
+        "    volumes:",
+        "      - /tmp/.X11-unix:/tmp/.X11-unix:rw",
+        "      - ${XDG_RUNTIME_DIR:-/run/user/1000}:${XDG_RUNTIME_DIR:-/run/user/1000}:rw",
+        "      - ${XAUTHORITY:-/tmp/.preppergpt-missing-xauthority}:/tmp/.Xauthority:ro"
+      ]
     : [];
   return [
     "services:",
@@ -60,7 +125,8 @@ function generatedCompose(plan, detection) {
     `      DEFAULT_MODELS: "${plan.defaultModel}"`,
     `      MODEL_ORDER_LIST: '${modelOrder.replaceAll("'", "''")}'`,
     `      TASK_MODEL: "${plan.selected.fast?.id || plan.defaultModel}"`,
-    ...gpuBlock
+    ...gpuBlock,
+    ...desktopBlock
   ].join("\n") + "\n";
 }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "preppergpt",
-  "version": "0.1.1",
-  "description": "A local-first ChatGPT-like field kit built on OpenWebUI and local models.",
+  "version": "0.1.3",
+  "description": "A post-apocalyptic local AI field kit for running a ChatGPT-like experience when hosted services are unavailable.",
   "type": "module",
   "bin": {
     "preppergpt": "bin/preppergpt.js"
@@ -28,7 +28,9 @@
     "llm",
     "ollama",
     "preppergpt",
-    "offline-ai"
+    "offline-ai",
+    "survival",
+    "post-apocalyptic"
   ],
   "homepage": "https://github.com/teamslop/preppergpt#readme",
   "bugs": {

package/profiles/models.json

@@ -5,8 +5,8 @@
       "label": "Max intelligence",
       "defaultModel": "glm52-q4-local",
       "roles": {
-        "chat": ["glm52-q4-local", "qwen3.6-35b-a3b:slopcode-cpu-64k", "qwen2.5-coder:14b", "llama3.1:8b"],
-        "reasoning": ["glm52-q4-local", "qwen3.6-35b-a3b:slopcode-cpu-64k", "qwen2.5-coder:14b"],
+        "chat": ["glm52-q8-local", "glm52-q4-local", "qwen3.6-35b-a3b:slopcode-cpu-64k", "qwen2.5-coder:14b", "llama3.1:8b"],
+        "reasoning": ["glm52-q8-local", "glm52-q4-local", "qwen3.6-35b-a3b:slopcode-cpu-64k", "qwen2.5-coder:14b"],
         "fast": ["gemma4:12b-256k-gpu", "llama3.1:8b"],
         "coding": ["qwen3.6-35b-a3b:slopcode-cpu-64k", "qwen2.5-coder:14b"],
         "research": ["deep-research-glm52"],
@@ -21,7 +21,7 @@
       "defaultModel": "local-chatgpt-auto",
       "roles": {
         "chat": ["local-chatgpt-auto", "gemma4:12b-256k-gpu", "glm52-q4-local", "llama3.1:8b"],
-        "reasoning": ["glm52-q4-local", "qwen3.6-35b-a3b:slopcode-cpu-64k", "qwen2.5-coder:14b"],
+        "reasoning": ["glm52-q8-local", "glm52-q4-local", "qwen3.6-35b-a3b:slopcode-cpu-64k", "qwen2.5-coder:14b"],
         "fast": ["gemma4:12b-256k-gpu", "llama3.1:8b"],
         "coding": ["qwen3.6-35b-a3b:slopcode-cpu-64k", "qwen2.5-coder:14b"],
         "research": ["deep-research-glm52"],
@@ -66,6 +66,26 @@
         "description": "Virtual OpenAI-compatible route exposed by the local-agent sidecar."
       }
     },
+    {
+      "id": "glm52-q8-local",
+      "name": "GLM 5.2 Q8 Local",
+      "roles": ["chat", "reasoning"],
+      "backend": "llama.cpp",
+      "contextTokens": 65536,
+      "qualityScore": 104,
+      "speedScore": 15,
+      "tpsEstimate": "very low tokens/sec may be acceptable in disaster/off-grid use because no hosted model is available; benchmark locally",
+      "requires": {
+        "minRamGb": 192,
+        "diskGb": 1000,
+        "nvme": true
+      },
+      "source": {
+        "type": "external",
+        "requiresHardwareFit": true,
+        "description": "Run a GLM 5.2 Q8 OpenAI-compatible llama.cpp server at http://127.0.0.1:11446/v1 with weights on fast NVMe for maximum local quality when hosted services are unavailable."
+      }
+    },
     {
       "id": "glm52-q4-local",
       "name": "GLM 5.2 Q4 Local",
@@ -74,7 +94,7 @@
       "contextTokens": 65536,
       "qualityScore": 100,
       "speedScore": 25,
-      "tpsEstimate": "0.4-3 completion tokens/sec on large CPU/NVMe builds; benchmark locally",
+      "tpsEstimate": "0.4-3 completion tokens/sec on large CPU/NVMe builds; acceptable for disaster/off-grid use when no hosted service is available; benchmark locally",
       "requires": {
         "minRamGb": 96,
         "diskGb": 520,
@@ -111,16 +131,18 @@
       "contextTokens": 262144,
       "qualityScore": 78,
       "speedScore": 96,
-      "tpsEstimate": "35-90 completion tokens/sec on a modern 16-24 GB NVIDIA GPU",
+      "tpsEstimate": "35-90 completion tokens/sec on a modern 16-24 GB NVIDIA GPU or supported Linux AMD ROCm GPU",
       "requires": {
         "minRamGb": 24,
         "minVramGb": 11,
-        "diskGb": 20
+        "diskGb": 20,
+        "gpuVendors": ["nvidia", "amd"],
+        "requiresRocm": true
       },
       "source": {
         "type": "ollama",
         "model": "gemma4:12b",
-        "description": "Pulled or provided through the local Ollama server."
+        "description": "Pulled or provided through the local Ollama server. AMD hosts use the Ollama ROCm container when ROCm is detected on Linux."
       }
     },
     {
@@ -131,16 +153,18 @@
       "contextTokens": 32768,
       "qualityScore": 76,
       "speedScore": 75,
-      "tpsEstimate": "12-45 completion tokens/sec depending on GPU and quantization",
+      "tpsEstimate": "12-45 completion tokens/sec depending on GPU vendor, ROCm/CUDA readiness, and quantization",
       "requires": {
         "minRamGb": 24,
         "minVramGb": 10,
-        "diskGb": 16
+        "diskGb": 16,
+        "gpuVendors": ["nvidia", "amd"],
+        "requiresRocm": true
       },
       "source": {
         "type": "ollama",
         "model": "qwen2.5-coder:14b",
-        "description": "Ollama coding fallback."
+        "description": "Ollama coding fallback. AMD hosts use the Ollama ROCm container when ROCm is detected on Linux."
       }
     },
     {
@@ -210,7 +234,9 @@
       "requires": {
         "minRamGb": 24,
         "minVramGb": 11,
-        "diskGb": 20
+        "diskGb": 20,
+        "gpuVendors": ["nvidia", "amd"],
+        "requiresRocm": true
       },
       "source": {
         "type": "virtual",
@@ -248,11 +274,13 @@
       "requires": {
         "minRamGb": 32,
         "minVramGb": 16,
-        "diskGb": 60
+        "diskGb": 60,
+        "gpuVendors": ["nvidia", "amd"],
+        "requiresRocm": true
       },
       "source": {
         "type": "manual",
-        "description": "Place Flux model, text encoder, and VAE files in the configured ComfyUI models directory."
+        "description": "Place Flux model, text encoder, and VAE files in the configured ComfyUI models directory. Use a CUDA or Linux ROCm ComfyUI runtime that matches the host GPU."
       }
     },
     {

package/services/local-scheduler/app.py

@@ -3780,11 +3780,11 @@ def local_parity_recommended_model(feature_family: str, primary_models: list[str
         return models[0] if models else None
 
     if "codex" in family or "software" in family or "code" in family:
-        return first_available(["slopcode-qwen-coder-local", "local-agent-glm52", "glm52-q4-local"])
+        return first_available(["slopcode-qwen-coder-local", "local-agent-glm52", "glm52-q8-local", "glm52-q4-local"])
     if "deep research" in family:
-        return first_available(["deep-research-glm52", "glm52-q4-local"])
+        return first_available(["deep-research-glm52", "glm52-q8-local", "glm52-q4-local"])
     if "developer mode" in family or "mcp" in family:
-        return first_available(["local-agent-glm52", "local-chatgpt-auto", "glm52-q4-local"])
+        return first_available(["local-agent-glm52", "local-chatgpt-auto", "glm52-q8-local", "glm52-q4-local"])
     if "image generation" in family:
         return first_available(["flux-2-klein-9b-fp8"])
     if "image editing" in family:
@@ -3794,16 +3794,16 @@ def local_parity_recommended_model(feature_family: str, primary_models: list[str
     if "voice" in family or "record mode" in family:
         return first_available(["whisper-base-bundled", "whisper-large-v3", "local-agent-glm52"])
     if "shopping" in family:
-        return first_available(["glm52-shopping-research-local", "glm52-q4-local"])
+        return first_available(["glm52-shopping-research-local", "glm52-q8-local", "glm52-q4-local"])
     if "job search" in family or "resume" in family or "finance" in family:
-        return first_available(["local-agent-glm52", "local-chatgpt-auto", "glm52-q4-local"])
+        return first_available(["local-agent-glm52", "local-chatgpt-auto", "glm52-q8-local", "glm52-q4-local"])
     if "study" in family:
-        return first_available(["glm52-study-coach-local", "glm52-q4-local"])
+        return first_available(["glm52-study-coach-local", "glm52-q8-local", "glm52-q4-local"])
     if "advanced reasoning" in family or "long context" in family:
-        return first_available(["glm52-q4-local"])
+        return first_available(["glm52-q8-local", "glm52-q4-local"])
     if "data analysis" in family or "canvas" in family or "memory" in family or "agent mode" in family:
-        return first_available(["local-agent-glm52", "glm52-q4-local"])
-    return first_available(["local-chatgpt-auto", "local-auto-router", "local-instant-gemma4-12b", "glm52-q4-local"])
+        return first_available(["local-agent-glm52", "glm52-q8-local", "glm52-q4-local"])
+    return first_available(["local-chatgpt-auto", "local-auto-router", "local-instant-gemma4-12b", "glm52-q8-local", "glm52-q4-local"])
 
 
 def local_parity_route_for_model(feature_family: str, model: str | None, profiles: dict) -> dict:
@@ -3833,10 +3833,10 @@ def local_parity_route_for_model(feature_family: str, model: str | None, profile
         route_id = "slopcode_tiny"
         route_type = "benchmarked_chat_route"
         action = "Select the Slopcode/Qwen coding model in OpenWebUI for local software work."
-    elif model_text == "glm52-q4-local" or "advanced reasoning" in family or "long context" in family:
+    elif model_text in {"glm52-q8-local", "glm52-q4-local"} or "advanced reasoning" in family or "long context" in family:
         route_id = "glm_tiny"
         route_type = "benchmarked_chat_route"
-        action = "Select GLM 5.2 Q4 in OpenWebUI for private long-context reasoning."
+        action = "Select the best available local GLM 5.2 route in OpenWebUI for private long-context reasoning."
     elif "shopping" in model_text:
         route_id = "glm52_shopping_research_preset"
         route_type = "chat_preset"
@@ -4462,9 +4462,9 @@ WORKFLOW_RECIPE_BLUEPRINTS = [
         "id": "private-long-context-workflow",
         "task_id": "private-long-context-reasoning",
         "title": "Private long-context reasoning with GLM 5.2",
-        "openwebui_entrypoint": "Model picker -> glm52-q4-local",
+        "openwebui_entrypoint": "Model picker -> glm52-q8-local on enterprise rigs, otherwise glm52-q4-local",
         "steps": [
-            "Select glm52-q4-local when privacy and context length matter more than latency.",
+            "Select glm52-q8-local on enterprise hardware when maximum local quality matters; otherwise select glm52-q4-local.",
             "Keep the prompt bounded when possible; use files/projects for reusable context.",
             "Use fast local routes for quick follow-ups when GLM latency is not needed.",
         ],
@@ -5293,6 +5293,7 @@ def local_parity_dashboard() -> dict:
         },
         "urls": {
             "openwebui": "http://127.0.0.1:8080",
+            "glm52_q8_openai": "http://127.0.0.1:11446/v1",
             "glm52_openai": "http://127.0.0.1:11441/v1",
             "slopcode_openai": "http://127.0.0.1:11438/v1",
             "deep_research_openai": "http://127.0.0.1:18041/v1",
@@ -5306,6 +5307,7 @@ def local_parity_dashboard() -> dict:
         },
         "primary_models": [
             {"id": "local-chatgpt-auto", "route": "fast_router", "best_for": "default local ChatGPT-like routing"},
+            {"id": "glm52-q8-local", "route": "glm_tiny", "context_tokens": 65536, "best_for": "enterprise 8-bit private long-context reasoning"},
             {"id": "glm52-q4-local", "route": "glm_tiny", "context_tokens": 65536, "best_for": "private long-context reasoning"},
             {
                 "id": "qwen3.6-35b-a3b:slopcode-cpu-64k",
@@ -6660,7 +6662,7 @@ def local_parity_audit_html() -> str:
       {metric("Starter prompts", f"{starter_summary.get('ready_starter_prompts')}/{starter_summary.get('starter_prompts')}", "prompt-library items")}
       {metric("Current release", f"{source_freshness_summary.get('current_release_covered_families')}/{source_freshness_summary.get('current_release_expected_families')}", "families")}
       {metric("Release evidence", f"{source_freshness_summary.get('current_release_covered_evidence_terms')}/{source_freshness_summary.get('current_release_expected_evidence_terms')}", "terms")}
-      {metric("Primary GLM route", "glm52-q4-local", "local long-context model")}
+      {metric("Primary GLM route", "glm52-q8-local / glm52-q4-local", "local long-context model")}
       {metric("Scope exclusions", f"{frontier_summary.get('excluded_from_local_goal_items')}/{frontier_summary.get('boundary_items')}", "hosted capabilities")}
       {metric("Evidence artifacts", f"{evidence_summary.get('ready_artifacts')}/{evidence_summary.get('artifacts')}", "privacy-safe proof")}
       {metric("Quality evals", scorecard_summary.get('quality_evals'), "executable")}
@@ -9653,7 +9655,7 @@ def local_parity_gap_report_html() -> str:
       {metric("Quality evals", summary.get('quality_evals'), "executable catalog")}
       {metric("Continuity", summary.get('continuity_status'), "fallback status")}
       {metric("Sources", summary.get('source_entries'), "source snapshot")}
-      {metric("Primary GLM route", "glm52-q4-local", "local long-context model")}
+      {metric("Primary GLM route", "glm52-q8-local / glm52-q4-local", "local long-context model")}
       {metric("GLM context", "65,536", "tokens")}
       {metric("Scope exclusions", f"{frontier_summary.get('excluded_from_local_goal_items')}/{frontier_summary.get('boundary_items')}", "hosted capabilities")}
     </section>
@@ -12797,7 +12799,7 @@ def local_model_route_recommendations() -> dict:
         "glm_tiny": {
             "title": "Private GLM 5.2 reasoning route",
             "benchmark_suite": "glm_tiny",
-            "default_model": "glm52-q4-local",
+            "default_model": "glm52-q8-local or glm52-q4-local",
             "target_tps": 0.1,
             "best_for": [
                 "private long-context reasoning",