Optimize startup: license cache, async validation

- Cache verified LicenseInfo in a static Mutex to avoid
  re-parsing and re-verifying Ed25519 on every call (6x → 1x)
- Make server license validation fire-and-forget so startup
  doesn't block on a 10s network timeout

Author: vdavid

apps/desktop/src-tauri/src/licensing/app_status.rs

@@ -381,6 +381,7 @@ pub fn get_window_title(status: &AppStatus) -> String {
 /// Reset license data (for testing only).
 #[cfg(debug_assertions)]
 pub fn reset_license(app: &tauri::AppHandle) {
+    crate::licensing::verification::clear_license_cache();
     if let Ok(store) = app.store("license.json") {
         store.delete("license_key");
         store.delete(STORE_KEY_CACHED_STATUS);

apps/desktop/src-tauri/src/licensing/verification.rs

@@ -6,8 +6,13 @@ use crate::licensing::validation_client::{activate_short_code, is_short_code};
 use base64::{Engine, engine::general_purpose::STANDARD as BASE64};
 use ed25519_dalek::{Signature, Verifier, VerifyingKey};
 use serde::{Deserialize, Serialize};
+use std::sync::Mutex;
 use tauri_plugin_store::StoreExt;
 
+/// In-memory cache for verified license info. Avoids re-parsing and re-verifying
+/// the Ed25519 signature on every call to `get_license_info`.
+static LICENSE_CACHE: Mutex<Option<LicenseInfo>> = Mutex::new(None);
+
 // Ed25519 public key (32 bytes, hex-encoded).
 // Generate this with: cd apps/license-server && pnpm run generate-keys
 // Then copy the public key here.
@@ -49,13 +54,20 @@ fn activate_license_internal(
         store.set(STORE_KEY_SHORT_CODE, serde_json::json!(code));
     }
 
-    Ok(LicenseInfo {
+    let info = LicenseInfo {
         email: data.email,
         transaction_id: data.transaction_id,
         issued_at: data.issued_at,
         organization_name: data.organization_name,
         short_code: short_code.map(|s| s.to_string()),
-    })
+    };
+
+    // Update the in-memory cache with the newly activated license
+    if let Ok(mut cache) = LICENSE_CACHE.lock() {
+        *cache = Some(info.clone());
+    }
+
+    Ok(info)
 }
 
 /// Activate a license key (full key, not short code). Returns the license info if valid.
@@ -79,21 +91,43 @@ pub async fn activate_license_async(app: &tauri::AppHandle, input: &str) -> Resu
     activate_license_internal(app, &full_key, short_code)
 }
 
-/// Get stored license info, if any.
+/// Get stored license info, if any. Returns a cached result after the first successful verification.
 pub fn get_license_info(app: &tauri::AppHandle) -> Option<LicenseInfo> {
+    // Fast path: return cached info if available
+    if let Ok(cache) = LICENSE_CACHE.lock()
+        && let Some(ref info) = *cache
+    {
+        return Some(info.clone());
+    }
+
+    // Slow path: read from store and verify Ed25519 signature
     let store = app.store("license.json").ok()?;
     let license_key = store.get(STORE_KEY_LICENSE)?.as_str()?.to_string();
     let short_code = store
         .get(STORE_KEY_SHORT_CODE)
         .and_then(|v| v.as_str().map(|s| s.to_string()));
 
-    validate_license_key(&license_key).ok().map(|data| LicenseInfo {
+    let info = validate_license_key(&license_key).ok().map(|data| LicenseInfo {
         email: data.email,
         transaction_id: data.transaction_id,
         issued_at: data.issued_at,
         organization_name: data.organization_name,
         short_code,
-    })
+    })?;
+
+    // Populate cache for subsequent calls
+    if let Ok(mut cache) = LICENSE_CACHE.lock() {
+        *cache = Some(info.clone());
+    }
+
+    Some(info)
+}
+
+/// Clear the in-memory license cache. Called when the license is reset.
+pub fn clear_license_cache() {
+    if let Ok(mut cache) = LICENSE_CACHE.lock() {
+        *cache = None;
+    }
 }
 
 /// Validate a license key and extract the data.

apps/desktop/src/routes/(main)/+page.svelte

@@ -444,15 +444,13 @@
         // Register known dialog types with backend (for MCP "available dialogs" resource)
         void registerKnownDialogs(SOFT_DIALOG_REGISTRY)
 
-        // Load license status first (non-blocking - don't prevent app load on failure)
+        // Load license status from cache (fast, no network)
         try {
-            let licenseStatus = await loadLicenseStatus()
+            const licenseStatus = await loadLicenseStatus()
 
-            // Trigger background validation if needed
-            const validatedStatus = await triggerValidationIfNeeded()
-            if (validatedStatus) {
-                licenseStatus = validatedStatus
-            }
+            // Fire-and-forget: validate with server in background if needed.
+            // Updates the cache silently; next launch picks up the result.
+            void triggerValidationIfNeeded()
 
             // Check if we need to show expiration modal
             if (licenseStatus.type === 'expired' && licenseStatus.showModal) {