chore(release): v0.1.1 — sidecar lifecycle, memory-cap auto-sync, RAM indicator

Three user-facing fixes landing as v0.1.1, all in the Tauri control plane
(no server / inference changes).

* fix(lumen-app): kill sidecar lumen-server on app exit
  - Tauri's RunEvent::ExitRequested fires on the event-loop thread and
    Tauri 2 may std::process::exit() before any tokio runtime drop, so
    `kill_on_drop(true)` on the spawned `tokio::process::Child` never
    actually delivers the kill. The orphaned lumen-server kept the port
    and the model's wired RAM resident across app launches.
  - New synchronous `ServerSupervisor::shutdown_blocking()` grabs the PID
    via try_lock and sends SIGTERM directly through `nix::kill`, polls
    every 100 ms for up to 3 s, then SIGKILL fallback. No tokio runtime
    dependency — works after the runtime has been torn down.
  - main.rs switches from `.run(ctx)` to `.build(ctx).run(closure)` so
    we can hook ExitRequested and call shutdown_blocking() before the
    process exits.

* fix(lumen-app): reclaim port at server start when prior sidecar leaked
  - Defense-in-depth for the case where shutdown_blocking() never ran
    (hard force-quit via Activity Monitor, panic mid-cleanup, etc.). On
    `start()` we run `lsof -nP -iTCP:PORT -sTCP:LISTEN -t` and, for each
    listening PID, verify via `ps -o comm=` that argv0 contains
    "lumen-server" before sending SIGTERM/SIGKILL. Unrelated services on
    the same port are left alone — the spawn will fail loudly instead.

* fix(lumen-app): auto-sync Metal memory caps to active model + ctx
  - The METAL MEMORY card displayed two different sets of numbers: a
    "tuned for <model> + ctx N (W/C/M GB)" hint computed from the active
    model + context size, and the live input values which held whatever
    `reset_memory_caps` had stored (system-default 70/2/85% of RAM).
    On a 24 GB Mac with an 11 GB model + ctx 8192, hint said
    10.742 / 2.000 / 13.742 but inputs showed 16 / 2 / 20.
  - New `syncTunedMemoryCaps()` runs on (a) `setActive` (model change),
    (b) `saveContext` (ctx change), (c) `onMount` (heal stale caps from
    pre-feature sessions). `wired_limit_gb` cleared to null so the
    backend emits byte-exact LUMEN_WIRED_LIMIT_BYTES from the safetensors
    size — no GB-rounding that could truncate a 14.45 GB model to a
    14 GB ceiling. No-op when already in sync or no active model is set.

* feat(lumen-app): live system memory indicator in topbar
  - New `sysinfo::current_memory_usage()` parses `vm_stat`:
    used = (wired + active + compressor-occupied) × page_size — same
    formula Activity Monitor uses for "Memory Used". No new crate dep.
  - `get_memory_usage` Tauri command polled every 2 s alongside the
    existing metrics poll.
  - Topbar actions row renders a compact `X.X/Y GB` chip with an inline
    mini bar; >=80% turns warn-colored, >=92% turns hot. Helps the
    operator catch wired-limit/RAM-pressure issues before the OS starts
    paging or the GPU starts evicting weights.

Version bumped in three places per docs/release.md:
- crates/lumen-app/Cargo.toml         0.1.0 -> 0.1.1
- crates/lumen-app/tauri.conf.json    0.1.0 -> 0.1.1
- crates/lumen-app/frontend/package.json 0.1.0 -> 0.1.1

Author: rabbitson87

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "lumen-app"
-version = "0.1.0"
+version = "0.1.1"
 edition.workspace = true
 rust-version.workspace = true
 license.workspace = true

crates/lumen-app/Cargo.toml

@@ -1,7 +1,7 @@
 {
   "name": "lumen-app-frontend",
   "private": true,
-  "version": "0.1.0",
+  "version": "0.1.1",
   "type": "module",
   "scripts": {
     "dev": "vite --port 5173 --strictPort",

crates/lumen-app/frontend/package.json

@@ -15,6 +15,7 @@
     type Catalog,
     type RecommendedModel,
     type SystemInfo,
+    type MemoryUsage,
     type CorsMode,
   } from "./lib/api";
   import EnvOverrides from "./lib/EnvOverrides.svelte";
@@ -55,6 +56,7 @@
   let typedEnvKeys = $state<Set<string>>(new Set());
   let catalog = $state<Catalog>({ families: [], recommended: [], embeddings: [] });
   let systemInfo = $state<SystemInfo | null>(null);
+  let memoryUsage = $state<MemoryUsage | null>(null);
   let selectedRecommend = $state<string>("");
 
   let visibleModels = $derived(models.filter((m) => m.supported));
@@ -169,6 +171,12 @@
       console.error("doctor run failed:", e);
     }
 
+    // Heal any stale memory caps left over from a previous session that
+    // pre-dates the auto-tune feature (e.g. system-default 16/2/20 saved
+    // before an active model existed). No-op if caps already match the
+    // tuned recommendation or no model is active.
+    await syncTunedMemoryCaps();
+
     unlistenLog = await onLog((l) => {
       logs = [...logs.slice(-499), l];
     });
@@ -196,10 +204,19 @@
       }
     });
 
+    try {
+      memoryUsage = await api.getMemoryUsage();
+    } catch (e) {
+      console.error("get_memory_usage failed:", e);
+    }
+
     pollHandle = setInterval(async () => {
       if (status.state === "running") {
         metrics = await api.serverMetrics();
       }
+      try {
+        memoryUsage = await api.getMemoryUsage();
+      } catch {}
     }, 2000);
   });
 
@@ -227,6 +244,32 @@
   async function setActive(id: string) {
     if (!config) return;
     config = await api.setActiveModel(id);
+    // Without this, switching models leaves the previous model's caps in
+    // place (e.g. 16 GB wired saved for a 16 GB model is wildly oversized
+    // for an 11 GB one). Re-tune to track the new model + current ctx.
+    await syncTunedMemoryCaps();
+  }
+
+  /// Sync the persisted Metal memory caps to the tuned recommendation
+  /// derived from the active model + current context. No-op when no active
+  /// model is set (system defaults stay in place) or values already match.
+  /// `wired_limit_gb = null` so the backend emits byte-exact
+  /// `LUMEN_WIRED_LIMIT_BYTES` from `active_model.size_bytes` instead of a
+  /// GB-rounded ceiling that could truncate a 14.45 GB model to 14 GB.
+  async function syncTunedMemoryCaps() {
+    if (!config || !activeModel) return;
+    if (recommendedMemoryGb == null || recommendedCacheGb == null) return;
+    const needsUpdate =
+      config.server.wired_limit_gb !== null ||
+      config.server.cache_limit_gb !== recommendedCacheGb ||
+      config.server.memory_limit_gb !== recommendedMemoryGb ||
+      config.server.disable_wired_limit;
+    if (!needsUpdate) return;
+    config.server.wired_limit_gb = null;
+    config.server.cache_limit_gb = recommendedCacheGb;
+    config.server.memory_limit_gb = recommendedMemoryGb;
+    config.server.disable_wired_limit = false;
+    config = await api.updateServerConfig(config.server);
   }
 
   async function saveServer() {
@@ -244,6 +287,9 @@
   async function saveContext() {
     if (!config) return;
     config = await api.updateContextConfig(config.context);
+    // ctx affects KV-cache headroom in the tuned memory recommendation
+    // (~1 GB per 8K tokens). Re-sync so saved caps follow.
+    await syncTunedMemoryCaps();
   }
 
   async function resetMemoryCaps() {
@@ -307,6 +353,22 @@
   </div>
   <div class="actions">
     {#if statusMessage}<span class="dim">{statusMessage}</span>{/if}
+    {#if memoryUsage}
+      {@const usedGb = memoryUsage.used_bytes / 1024 ** 3}
+      {@const totalGb = memoryUsage.total_bytes / 1024 ** 3}
+      {@const pct = (usedGb / totalGb) * 100}
+      <span
+        class="mem-indicator mono"
+        class:warn={pct >= 80 && pct < 92}
+        class:hot={pct >= 92}
+        title="System memory: {usedGb.toFixed(1)} / {totalGb.toFixed(0)} GB ({pct.toFixed(0)}%) — wired + active + compressor"
+      >
+        <span class="mem-bar">
+          <span class="mem-bar-fill" style="width: {Math.min(100, pct).toFixed(1)}%"></span>
+        </span>
+        {usedGb.toFixed(1)}/{totalGb.toFixed(0)} GB
+      </span>
+    {/if}
     <button
       class="health"
       class:healthy={doctorReport?.overall === "healthy"}
@@ -1054,6 +1116,46 @@
     margin-left: 2px;
   }
 
+  .mem-indicator {
+    display: inline-flex;
+    align-items: center;
+    gap: 6px;
+    font-size: 11px;
+    color: var(--text-dim);
+    padding: 2px 8px;
+    border: 1px solid var(--border);
+    border-radius: 6px;
+    background: var(--panel);
+  }
+  .mem-indicator.warn {
+    color: var(--warn);
+    border-color: var(--warn);
+  }
+  .mem-indicator.hot {
+    color: var(--err);
+    border-color: var(--err);
+  }
+  .mem-bar {
+    display: inline-block;
+    width: 48px;
+    height: 6px;
+    background: var(--border);
+    border-radius: 3px;
+    overflow: hidden;
+  }
+  .mem-bar-fill {
+    display: block;
+    height: 100%;
+    background: var(--text-dim);
+    transition: width 0.4s ease-out;
+  }
+  .mem-indicator.warn .mem-bar-fill {
+    background: var(--warn);
+  }
+  .mem-indicator.hot .mem-bar-fill {
+    background: var(--err);
+  }
+
   .grid {
     display: grid;
     grid-template-columns: repeat(3, minmax(0, 1fr));

crates/lumen-app/frontend/src/App.svelte

@@ -119,6 +119,11 @@ export interface SystemInfo {
   recommended: MemoryDefaults;
 }
 
+export interface MemoryUsage {
+  used_bytes: number;
+  total_bytes: number;
+}
+
 export type LifecycleState = "stopped" | "starting" | "running" | "stopping" | "crashed";
 
 export interface ServerStatus {
@@ -218,6 +223,7 @@ export const api = {
   openConfigDir: () => invoke<string>("open_config_dir"),
 
   getSystemInfo: () => invoke<SystemInfo>("get_system_info"),
+  getMemoryUsage: () => invoke<MemoryUsage | null>("get_memory_usage"),
   resetMemoryCaps: () => invoke<PersistentConfig>("reset_memory_caps"),
 
   doctorRun: () => invoke<DoctorReport>("doctor_run"),

crates/lumen-app/frontend/src/lib/api.ts

@@ -11,7 +11,7 @@ use crate::doctor::{self, DoctorReport};
 use crate::models::{self, DownloadProgress, ModelEntry};
 use crate::server::{self, ServerStatus, TYPED_ENV_KEYS};
 use crate::state::AppState;
-use crate::sysinfo::{self, SystemInfo};
+use crate::sysinfo::{self, MemoryUsage, SystemInfo};
 
 /// Wrap anyhow::Error → String so Tauri can serialize it for the frontend.
 type CmdResult<T> = Result<T, String>;
@@ -104,6 +104,14 @@ pub async fn get_system_info() -> CmdResult<SystemInfo> {
     Ok(sysinfo::probe())
 }
 
+/// Live system memory snapshot for the topbar monitor. Returns `None` only
+/// if the `vm_stat` probe fails — the UI hides the indicator in that case
+/// rather than rendering nonsense.
+#[tauri::command]
+pub async fn get_memory_usage() -> CmdResult<Option<MemoryUsage>> {
+    Ok(sysinfo::current_memory_usage())
+}
+
 /// Reset the Metal memory caps in `ServerConfig` to RAM-aware defaults
 /// (70/20/85% of total installed RAM). Useful after the user manually
 /// fiddles with the caps and wants to restart from a known-good point.

crates/lumen-app/src/commands.rs

@@ -49,13 +49,24 @@ fn main() {
             commands::server_metrics,
             commands::open_config_dir,
             commands::get_system_info,
+            commands::get_memory_usage,
             commands::reset_memory_caps,
             commands::doctor_run,
             commands::doctor_fix,
             updater::check_for_updates,
             updater::install_update,
             updater::current_version,
         ])
-        .run(tauri::generate_context!())
-        .expect("error while running Lumen");
+        .build(tauri::generate_context!())
+        .expect("error while building Lumen")
+        .run(|app_handle, event| {
+            // Tauri may std::process::exit() after this returns, which skips
+            // tokio runtime drop and therefore skips Child::kill_on_drop on
+            // the sidecar. Send SIGTERM → SIGKILL synchronously here so the
+            // server's port + RAM are reclaimed before the app process dies.
+            if let tauri::RunEvent::ExitRequested { .. } = event {
+                let state: tauri::State<AppState> = app_handle.state();
+                state.supervisor.shutdown_blocking();
+            }
+        });
 }

crates/lumen-app/src/main.rs

@@ -280,6 +280,13 @@ impl ServerSupervisor {
         let bin = resolve_binary(cfg.server_binary_path.as_deref())
             .context("resolve lumen-server binary path")?;
 
+        // If a previous app exit (or force-quit / crash) left an orphaned
+        // lumen-server holding the configured port, reclaim it before
+        // spawning the new one — otherwise bind() fails with EADDRINUSE.
+        // Only kills processes whose argv0 name contains "lumen-server" to
+        // avoid wiping unrelated services on the same port.
+        reclaim_port_if_lumen_server(&cfg.server.host, cfg.server.port);
+
         let mut cmd = Command::new(&bin);
         cmd.stdout(Stdio::piped())
             .stderr(Stdio::piped())
@@ -384,6 +391,41 @@ impl ServerSupervisor {
         Ok(self.status().await)
     }
 
+    /// Synchronous best-effort kill for app-exit cleanup. Tauri's
+    /// `RunEvent::ExitRequested` fires on the event-loop thread and may
+    /// `std::process::exit()` before any tokio runtime drop, so we can't
+    /// rely on `kill_on_drop` or the async `stop()` path — both need a live
+    /// runtime. Instead grab the PID via `try_lock` and send signals
+    /// directly via `nix::kill`. SIGTERM → 3 s grace → SIGKILL fallback.
+    /// Returns silently if no server is running or the lock is contended
+    /// (treat both as "nothing to clean up").
+    pub fn shutdown_blocking(&self) {
+        use nix::sys::signal::{Signal, kill};
+        use nix::unistd::Pid;
+
+        let pid = match self.inner.try_lock() {
+            Ok(g) => g.pid,
+            Err(_) => return,
+        };
+        let Some(pid) = pid else { return };
+        let pid_t = Pid::from_raw(pid as i32);
+
+        if kill(pid_t, Signal::SIGTERM).is_err() {
+            return;
+        }
+
+        // Poll for exit every 100 ms up to 3 s. `kill(pid, 0)` returns Err
+        // (ESRCH) once the process is reaped — that's our exit signal.
+        for _ in 0..30 {
+            std::thread::sleep(Duration::from_millis(100));
+            if kill(pid_t, None).is_err() {
+                return;
+            }
+        }
+
+        let _ = kill(pid_t, Signal::SIGKILL);
+    }
+
     pub async fn stop(&self, app: AppHandle) -> Result<ServerStatus> {
         let pid = {
             let mut g = self.inner.lock().await;
@@ -685,6 +727,77 @@ pub fn resolve_binary_public(explicit: Option<&Path>) -> Result<PathBuf> {
     resolve_binary(explicit)
 }
 
+/// If `host:port` is occupied by a process whose argv0 name contains
+/// `lumen-server`, send it SIGTERM (then SIGKILL after a short grace) so
+/// `start()` can bind cleanly. No-op when:
+/// - nothing is listening on the port
+/// - the listener is some other process (we leave it alone; the spawn will
+///   fail loudly and surface as a port-collision error to the user)
+///
+/// macOS-only — uses `lsof` (always present on macOS) + `ps`. On other
+/// platforms this would need a different probe; Lumen ships Apple Silicon
+/// only so the cross-platform fork can wait.
+fn reclaim_port_if_lumen_server(host: &str, port: u16) {
+    use std::process::Command as StdCommand;
+
+    let lsof_target = if host == "0.0.0.0" || host.is_empty() {
+        format!("-iTCP:{}", port)
+    } else {
+        format!("-iTCP@{}:{}", host, port)
+    };
+    let out = match StdCommand::new("lsof")
+        .args(["-nP", &lsof_target, "-sTCP:LISTEN", "-t"])
+        .output()
+    {
+        Ok(o) if o.status.success() => o,
+        _ => return,
+    };
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    let pids: Vec<i32> = stdout
+        .lines()
+        .filter_map(|l| l.trim().parse::<i32>().ok())
+        .collect();
+    if pids.is_empty() {
+        return;
+    }
+
+    use nix::sys::signal::{Signal, kill};
+    use nix::unistd::Pid;
+
+    for pid in pids {
+        // Confirm it's actually a lumen-server before killing.
+        let ps_out = StdCommand::new("ps")
+            .args(["-p", &pid.to_string(), "-o", "comm="])
+            .output();
+        let is_lumen = match ps_out {
+            Ok(o) if o.status.success() => String::from_utf8_lossy(&o.stdout)
+                .trim()
+                .rsplit('/')
+                .next()
+                .map(|name| name.contains("lumen-server"))
+                .unwrap_or(false),
+            _ => false,
+        };
+        if !is_lumen {
+            continue;
+        }
+
+        let pid_t = Pid::from_raw(pid);
+        let _ = kill(pid_t, Signal::SIGTERM);
+        for _ in 0..20 {
+            std::thread::sleep(Duration::from_millis(100));
+            if kill(pid_t, None).is_err() {
+                break;
+            }
+        }
+        if kill(pid_t, None).is_ok() {
+            let _ = kill(pid_t, Signal::SIGKILL);
+            // brief settle so the kernel reclaims the socket before bind()
+            std::thread::sleep(Duration::from_millis(200));
+        }
+    }
+}
+
 /// Resolution order:
 /// 1. Explicit `cfg.server_binary_path` if set
 /// 2. Sibling binary in the .app bundle (Resources/lumen-server)