fix: reduce Windows hardware detection hangs

- Replace siCpu() with synchronous os.cpus() — no PowerShell needed
- Replace siMem() with os.totalmem() in detectSystemMemory
- Add 3s timeout to siMemLayout() and siGraphics() so they don't
  block indefinitely behind monitoring's PowerShell queue
- Slow memory polling to 3s on Windows (was 1s) to free up the
  shared PowerShell session for hardware detection queries
- Split SystemTab loading: render version info immediately,
  hardware info fills in as background tasks complete

src/components/settings/SystemTab.tsx

@@ -24,7 +24,13 @@ export const SystemTab = () => {
 
         setVersionInfo(info);
         setKoboldVersion(currentBackend?.version ?? null);
+      } catch (error) {
+        window.electronAPI.logs.logError('Failed to load system info', error as Error);
+      } finally {
+        setLoading(false);
+      }
 
+      try {
         const [cpu, gpu, gpuCapabilities, gpuMemory, systemMemory] = await Promise.all([
           window.electronAPI.kobold.detectCPU(),
           window.electronAPI.kobold.detectGPU(),
@@ -41,9 +47,7 @@ export const SystemTab = () => {
           systemMemory,
         });
       } catch (error) {
-        window.electronAPI.logs.logError('Failed to load system info', error as Error);
+        window.electronAPI.logs.logError('Failed to load hardware info', error as Error);
-      } finally {
-        setLoading(false);
       }
     };
 

src/main/modules/hardware.ts

@@ -1,7 +1,8 @@
+import { cpus as osCpus, totalmem } from 'node:os';
 import { platform } from 'node:process';
 
 import { execa } from 'execa';
-import { cpu as siCpu, mem as siMem, memLayout as siMemLayout } from 'systeminformation';
+import { memLayout as siMemLayout } from 'systeminformation';
 
 import type {
   BasicGPUInfo,
@@ -33,36 +34,26 @@ let basicGPUInfoCache: BasicGPUInfo | null = null;
 let gpuCapabilitiesCache: GPUCapabilities | null = null;
 let gpuMemoryInfoCache: GPUMemoryInfo[] | null = null;
 
-export async function detectCPU() {
+export function detectCPU() {
   if (cpuCapabilitiesCache) {
     return cpuCapabilitiesCache;
   }
 
-  const result = await safeExecute(async () => {
+  const cpuList = osCpus();
-    const cpu = await siCpu();
+  const brand = cpuList[0]?.model;
+  const cores = cpuList.length;
+  const speed = (cpuList[0]?.speed ?? 0) / 1000;
 
-    const devices: { name: string; detailedName: string }[] = [];
+  const devices: { name: string; detailedName: string }[] = [];
-    if (cpu.brand) {
+  if (brand) {
-      const name = formatDeviceName(cpu.brand);
+    const name = formatDeviceName(brand);
-
+    devices.push({
-      devices.push({
+      detailedName: `${name} (${cores} cores) @ ${speed} GHz`,
-        detailedName: `${name} (${cpu.cores} cores) @ ${cpu.speed} GHz`,
+      name,
-        name,
+    });
-      });
+  }
-    }
-
-    const capabilities = {
-      devices,
-    };
-
-    cpuCapabilitiesCache = capabilities;
-    return capabilities;
-  }, 'CPU detection failed');
-
-  cpuCapabilitiesCache = result ?? {
-    devices: [],
-  };
 
+  cpuCapabilitiesCache = { devices };
   return cpuCapabilitiesCache;
 }
 
@@ -370,10 +361,13 @@ export async function detectGPUMemory() {
 }
 
 export const detectSystemMemory = async () => {
-  try {
+  const totalGB = (totalmem() / 1024 ** 3).toFixed(2);
-    const [memInfo, memLayout] = await Promise.all([siMem(), siMemLayout()]);
 
-    const totalGB = (memInfo.total / 1024 ** 3).toFixed(2);
+  try {
+    const memLayout = await Promise.race([
+      siMemLayout(),
+      new Promise<never>((_, reject) => setTimeout(() => reject(new Error('timeout')), 3000)),
+    ]);
 
     let speed: number | undefined;
     let type: string | undefined;
@@ -394,15 +388,8 @@ export const detectSystemMemory = async () => {
       }
     }
 
-    return {
+    return { speed, totalGB, type };
-      speed,
-      totalGB,
-      type,
-    };
   } catch {
-    const mem = await siMem();
+    return { totalGB };
-    return {
-      totalGB: (mem.total / 1024 ** 3).toFixed(2),
-    };
   }
 };

src/main/modules/monitoring.ts

@@ -61,6 +61,7 @@ let memoryInterval: ReturnType<typeof setInterval> | null = null;
 let gpuInterval: ReturnType<typeof setInterval> | null = null;
 let isRunning = false;
 const updateFrequency = 1000;
+const memoryUpdateFrequency = platform === 'win32' ? 3000 : updateFrequency;
 let mainWindow: BrowserWindow | null = null;
 
 let latestCpuMetrics: CpuMetrics | null = null;
@@ -87,7 +88,7 @@ export function startMonitoring(window: BrowserWindow) {
   void collectAndSendMemoryMetrics();
   memoryInterval = setInterval(() => {
     void collectAndSendMemoryMetrics();
-  }, updateFrequency);
+  }, memoryUpdateFrequency);
 
   if (platform === 'linux') {
     void collectAndSendGpuMetrics();

src/utils/node/gpu.ts

@@ -151,7 +151,10 @@ async function getLinuxGPUData() {
 
 async function getWindowsGPUData() {
   try {
-    const graphics = await siGraphics();
+    const graphics = await Promise.race([
+      siGraphics(),
+      new Promise<never>((_, reject) => setTimeout(() => reject(new Error('timeout')), 3000)),
+    ]);
 
     const discreteControllers = graphics.controllers.filter(
       (controller) => controller.vram && controller.vram >= 1024,