AI settings: fix and extract AI gauge logic

Author: vdavid

apps/desktop/src-tauri/src/ai/manager.rs

@@ -364,28 +364,107 @@ pub fn get_ai_runtime_status() -> AiRuntimeStatus {
     }
 }
 
-/// System memory info returned to frontend for the RAM gauge.
-#[derive(Debug, Clone, serde::Serialize)]
+/// System memory breakdown returned to frontend for the RAM gauge.
+/// Categories are non-overlapping and sum to `total_bytes`.
+#[derive(Debug, Clone, serde::Serialize, PartialEq, Eq)]
 #[serde(rename_all = "camelCase")]
 pub struct SystemMemoryInfo {
     pub total_bytes: u64,
-    /// Memory actively used by processes (app + wired + compressed on macOS).
-    pub used_bytes: u64,
-    /// Memory available for new allocations (free + inactive + purgeable on macOS).
-    pub available_bytes: u64,
+    /// Wired + compressor-occupied memory (kernel, drivers — can't be freed).
+    pub wired_bytes: u64,
+    /// App memory: active + inactive - purgeable (process memory the user can free by quitting apps).
+    pub app_bytes: u64,
+    /// Free: free + purgeable + speculative (available for new allocations).
+    pub free_bytes: u64,
 }
 
-/// Returns system memory info (total, used by processes, and available).
-/// Uses the `sysinfo` crate for cross-platform accuracy.
+/// Returns system memory breakdown using macOS `host_statistics64` for accurate,
+/// non-overlapping categories (unlike `sysinfo` where used + available > total).
 #[tauri::command]
 pub fn get_system_memory_info() -> SystemMemoryInfo {
-    let mut sys = sysinfo::System::new();
-    sys.refresh_memory();
-    SystemMemoryInfo {
-        total_bytes: sys.total_memory(),
-        used_bytes: sys.used_memory(),
-        available_bytes: sys.available_memory(),
+    get_system_memory_info_inner()
+}
+
+/// Testable inner function that reads macOS vm_statistics64 via Mach API.
+pub fn get_system_memory_info_inner() -> SystemMemoryInfo {
+    #[cfg(target_os = "macos")]
+    {
+        macos_memory_info()
+    }
+    #[cfg(not(target_os = "macos"))]
+    {
+        // Fallback for non-macOS: use sysinfo (best effort)
+        let mut sys = sysinfo::System::new();
+        sys.refresh_memory();
+        let total = sys.total_memory();
+        let used = sys.used_memory();
+        let free = total.saturating_sub(used);
+        SystemMemoryInfo {
+            total_bytes: total,
+            wired_bytes: 0,
+            app_bytes: used,
+            free_bytes: free,
+        }
+    }
+}
+
+/// Reads macOS vm_statistics64 via `host_statistics64` for accurate memory breakdown.
+#[cfg(target_os = "macos")]
+fn macos_memory_info() -> SystemMemoryInfo {
+    use std::mem;
+
+    let total_bytes = {
+        let mut sys = sysinfo::System::new();
+        sys.refresh_memory();
+        sys.total_memory()
+    };
+
+    // Safety: calling Mach kernel API with proper struct size.
+    let page_size: u64;
+    let (wired_pages, compressor_pages, internal_pages, purgeable_pages);
+
+    unsafe {
+        page_size = libc::sysconf(libc::_SC_PAGESIZE) as u64;
+
+        #[allow(deprecated, reason = "libc says use mach2, but not worth a new dep for one call")]
+        let host = libc::mach_host_self();
+        let mut vm_info: libc::vm_statistics64 = mem::zeroed();
+        let mut count = (size_of::<libc::vm_statistics64>() / size_of::<libc::integer_t>()) as u32;
+
+        let ret = libc::host_statistics64(
+            host,
+            libc::HOST_VM_INFO64,
+            &mut vm_info as *mut _ as *mut libc::integer_t,
+            &mut count,
+        );
+
+        if ret != libc::KERN_SUCCESS {
+            log::warn!("host_statistics64 returned {ret}, falling back to sysinfo");
+            let mut sys = sysinfo::System::new();
+            sys.refresh_memory();
+            let used = sys.used_memory();
+            return SystemMemoryInfo {
+                total_bytes,
+                wired_bytes: 0,
+                app_bytes: used,
+                free_bytes: total_bytes.saturating_sub(used),
+            };
+        }
+
+        wired_pages = vm_info.wire_count as u64;
+        compressor_pages = vm_info.compressor_page_count as u64;
+        // internal_page_count = anonymous pages owned by processes (what Activity Monitor calls "App Memory").
+        // Unlike active+inactive, this excludes file-backed cache that macOS freely reclaims.
+        internal_pages = vm_info.internal_page_count as u64;
+        purgeable_pages = vm_info.purgeable_count as u64;
     }
+
+    let wired_bytes = (wired_pages + compressor_pages) * page_size;
+    let app_bytes = internal_pages.saturating_sub(purgeable_pages) * page_size;
+    // Free = everything not wired or app (includes file cache, inactive, purgeable, speculative)
+    let free_bytes = total_bytes.saturating_sub(wired_bytes + app_bytes);
+
+    SystemMemoryInfo { total_bytes, wired_bytes, app_bytes, free_bytes }
 }
 
 /// Stores provider + context size + OpenAI config in manager state.
@@ -980,4 +1059,40 @@ mod tests {
         let status = get_ai_status();
         assert_eq!(status, AiStatus::Unavailable);
     }
+
+    #[test]
+    fn test_system_memory_info_adds_up() {
+        let info = get_system_memory_info_inner();
+
+        // Total must be positive (every machine has RAM)
+        assert!(info.total_bytes > 0, "total_bytes should be positive");
+
+        // Non-overlapping segments must sum to total
+        let sum = info.wired_bytes + info.app_bytes + info.free_bytes;
+        assert_eq!(
+            sum, info.total_bytes,
+            "wired ({}) + app ({}) + free ({}) = {} != total ({})",
+            info.wired_bytes, info.app_bytes, info.free_bytes, sum, info.total_bytes,
+        );
+
+        // Each segment should be reasonable (not more than total)
+        assert!(info.wired_bytes <= info.total_bytes);
+        assert!(info.app_bytes <= info.total_bytes);
+        assert!(info.free_bytes <= info.total_bytes);
+    }
+
+    #[test]
+    fn test_system_memory_info_serialization() {
+        let info = SystemMemoryInfo {
+            total_bytes: 68_719_476_736,
+            wired_bytes: 5_000_000_000,
+            app_bytes: 30_000_000_000,
+            free_bytes: 33_719_476_736,
+        };
+        let json = serde_json::to_string(&info).unwrap();
+        assert!(json.contains("\"totalBytes\":68719476736"));
+        assert!(json.contains("\"wiredBytes\":5000000000"));
+        assert!(json.contains("\"appBytes\":30000000000"));
+        assert!(json.contains("\"freeBytes\":33719476736"));
+    }
 }

apps/desktop/src/lib/settings/sections/AiSection.svelte

@@ -35,6 +35,7 @@
         type SystemMemoryInfo,
     } from '$lib/tauri-commands'
     import { createShouldShow } from '$lib/settings/settings-search'
+    import { computeGaugeSegments } from './ram-gauge-utils'
     import { getAppLogger } from '$lib/logging/logger'
 
     interface Props {
@@ -565,66 +566,9 @@
     const showApplyButton = $derived(pendingContextSize !== activeContextSize && serverRunning && !isRestarting)
 
     // RAM gauge segments (percentages of total RAM)
-    // Left-to-right: other | retained AI | change (freed or added) | free (bar background)
-    // "retained AI" = AI memory that stays after applying the new context size
-    // "change" = freed (shrinking, green) or added (growing, gold 50%)
-    // Segments: System | Other apps | Cmdr AI (retained/added/freed) | Free
-    // All segments sum to <= 100%; remainder is the bar background (free memory).
-    const gaugeSegments = $derived.by(() => {
-        if (!systemMemory || systemMemory.totalBytes === 0) return null
-
-        const total = systemMemory.totalBytes
-        const usedByProcesses = systemMemory.usedBytes
-        const availableBytes = systemMemory.availableBytes
-
-        // System = kernel overhead, wired, compressed (not attributed to any process)
-        const systemBytes = Math.max(0, total - usedByProcesses - availableBytes)
-        // Other apps = all process memory minus our AI estimate
-        const otherAppsBytes = Math.max(0, usedByProcesses - currentAiMemoryBytes)
-
-        const systemPercent = (systemBytes / total) * 100
-        const otherAppsPercent = (otherAppsBytes / total) * 100
-        const delta = projectedAiMemoryBytes - currentAiMemoryBytes
-
-        // When shrinking: split current AI into "retained" (projected) + "freed" (|delta|)
-        // When growing: current AI stays, delta is added after it
-        // When unchanged: just current AI
-        let retainedAiPercent: number
-        let addedPercent: number
-        let freedPercent: number
-
-        if (delta > 0) {
-            retainedAiPercent = (currentAiMemoryBytes / total) * 100
-            addedPercent = (delta / total) * 100
-            freedPercent = 0
-        } else if (delta < 0) {
-            retainedAiPercent = (projectedAiMemoryBytes / total) * 100
-            addedPercent = 0
-            freedPercent = (Math.abs(delta) / total) * 100
-        } else {
-            retainedAiPercent = (currentAiMemoryBytes / total) * 100
-            addedPercent = 0
-            freedPercent = 0
-        }
-
-        // Clamp so segments never exceed 100% total
-        const segmentTotal = systemPercent + otherAppsPercent + retainedAiPercent + addedPercent + freedPercent
-        const scale = segmentTotal > 100 ? 100 / segmentTotal : 1
-
-        const totalProjectedUsage = systemBytes + otherAppsBytes + projectedAiMemoryBytes
-
-        return {
-            systemPercent: systemPercent * scale,
-            otherAppsPercent: otherAppsPercent * scale,
-            retainedAiPercent: retainedAiPercent * scale,
-            addedPercent: addedPercent * scale,
-            freedPercent: freedPercent * scale,
-            totalProjectedUsageRatio: totalProjectedUsage / total,
-            systemBytes,
-            otherAppsBytes,
-            availableBytes,
-        }
-    })
+    const gaugeSegments = $derived(
+        systemMemory ? computeGaugeSegments(systemMemory, currentAiMemoryBytes, projectedAiMemoryBytes) : null,
+    )
 
     // Warning state based on projected usage
     const warningLevel = $derived.by((): 'none' | 'caution' | 'danger' => {
@@ -1127,7 +1071,7 @@
                             {/if}
                             <span class="ram-legend-item"
                                 ><span class="ram-legend-swatch ram-free-space"></span>Free {formatMemoryGb(
-                                    gaugeSegments.availableBytes,
+                                    gaugeSegments.freeBytes,
                                 )}</span
                             >
                         </div>

apps/desktop/src/lib/settings/sections/ram-gauge-utils.test.ts

@@ -0,0 +1,111 @@
+import { describe, it, expect } from 'vitest'
+import { computeGaugeSegments, type GaugeSegments } from './ram-gauge-utils'
+import type { SystemMemoryInfo } from '$lib/tauri-commands'
+
+const GB = 1024 * 1024 * 1024
+
+/** Helper: builds a SystemMemoryInfo where segments sum to total. */
+function mem(totalGb: number, wiredGb: number, appGb: number, freeGb: number): SystemMemoryInfo {
+    return { totalBytes: totalGb * GB, wiredBytes: wiredGb * GB, appBytes: appGb * GB, freeBytes: freeGb * GB }
+}
+
+/** Asserts the result is non-null and returns it typed. */
+function expectSegments(memory: SystemMemoryInfo, currentAi: number, projectedAi: number): GaugeSegments {
+    const result = computeGaugeSegments(memory, currentAi, projectedAi)
+    expect(result).not.toBeNull()
+    return result as GaugeSegments
+}
+
+describe('computeGaugeSegments', () => {
+    it('returns null when total is 0', () => {
+        expect(computeGaugeSegments(mem(0, 0, 0, 0), 0, 0)).toBeNull()
+    })
+
+    it('segments add up to <= 100%', () => {
+        const result = expectSegments(mem(64, 5, 30, 29), 3.5 * GB, 3.5 * GB)
+        const sum =
+            result.systemPercent +
+            result.otherAppsPercent +
+            result.retainedAiPercent +
+            result.addedPercent +
+            result.freedPercent
+        expect(sum).toBeLessThanOrEqual(100.01) // floating point tolerance
+        expect(sum).toBeGreaterThan(0)
+    })
+
+    it('system segment uses wired bytes (non-zero for real systems)', () => {
+        const result = expectSegments(mem(64, 5, 30, 29), 3.5 * GB, 3.5 * GB)
+        expect(result.systemBytes).toBe(5 * GB)
+        expect(result.systemPercent).toBeCloseTo((5 / 64) * 100, 1)
+    })
+
+    it('other apps = app memory minus AI memory', () => {
+        const result = expectSegments(mem(64, 5, 30, 29), 3.5 * GB, 3.5 * GB)
+        expect(result.otherAppsBytes).toBe(26.5 * GB)
+    })
+
+    it('free bytes come directly from system memory', () => {
+        const result = expectSegments(mem(64, 5, 30, 29), 3.5 * GB, 3.5 * GB)
+        expect(result.freeBytes).toBe(29 * GB)
+    })
+
+    it('other apps bytes are clamped to 0 when AI estimate exceeds app memory', () => {
+        // AI estimate larger than reported app memory (edge case during model load)
+        const result = expectSegments(mem(64, 5, 2, 57), 3.5 * GB, 3.5 * GB)
+        expect(result.otherAppsBytes).toBe(0)
+    })
+
+    it('shows added segment when projected > current (growing)', () => {
+        const current = 2 * GB
+        const projected = 4 * GB
+        const result = expectSegments(mem(64, 5, 30, 29), current, projected)
+        expect(result.addedPercent).toBeGreaterThan(0)
+        expect(result.freedPercent).toBe(0)
+        expect(result.retainedAiPercent).toBeCloseTo((2 / 64) * 100, 1)
+        expect(result.addedPercent).toBeCloseTo((2 / 64) * 100, 1)
+    })
+
+    it('shows freed segment when projected < current (shrinking)', () => {
+        const current = 4 * GB
+        const projected = 2 * GB
+        const result = expectSegments(mem(64, 5, 30, 29), current, projected)
+        expect(result.freedPercent).toBeGreaterThan(0)
+        expect(result.addedPercent).toBe(0)
+        expect(result.retainedAiPercent).toBeCloseTo((2 / 64) * 100, 1)
+        expect(result.freedPercent).toBeCloseTo((2 / 64) * 100, 1)
+    })
+
+    it('no change segments when projected == current', () => {
+        const result = expectSegments(mem(64, 5, 30, 29), 3 * GB, 3 * GB)
+        expect(result.addedPercent).toBe(0)
+        expect(result.freedPercent).toBe(0)
+    })
+
+    it('clamps to 100% when segments would overflow', () => {
+        // Extreme case: all memory categories are huge relative to total
+        const result = expectSegments(mem(16, 4, 10, 2), 6 * GB, 10 * GB)
+        const sum =
+            result.systemPercent +
+            result.otherAppsPercent +
+            result.retainedAiPercent +
+            result.addedPercent +
+            result.freedPercent
+        expect(sum).toBeLessThanOrEqual(100.01)
+    })
+
+    it('totalProjectedUsageRatio reflects projected AI, not current', () => {
+        const current = 2 * GB
+        const projected = 6 * GB
+        const result = expectSegments(mem(64, 5, 30, 29), current, projected)
+        // system(5) + otherApps(30-2=28) + projected(6) = 39 / 64 ≈ 0.609
+        expect(result.totalProjectedUsageRatio).toBeCloseTo(39 / 64, 2)
+    })
+
+    it('AI server not running (0 current) shows only projected as added', () => {
+        const result = expectSegments(mem(64, 5, 30, 29), 0, 3.5 * GB)
+        expect(result.retainedAiPercent).toBe(0)
+        expect(result.addedPercent).toBeCloseTo((3.5 / 64) * 100, 1)
+        // Other apps = full app memory since AI current is 0
+        expect(result.otherAppsBytes).toBe(30 * GB)
+    })
+})