fix(desktop): Update-Klick prueft frisch statt veralteten Stand zu installieren

Der Tray-Eintrag installierte das beim letzten Check abgelegte Update. Die
Download-Adresse liefert aber immer den aktuellen Installer; nach einem
Server-Update passte die alte Signatur nicht zur neuen Datei ("signature
verification failed", danach Browser-Rueckfall; Nutzer 29.09.). Jetzt
prueft der Klick erst frisch (install_after) und installiert das Ergebnis.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

apps/desktop/src-tauri/src/lib.rs

@@ -461,7 +461,15 @@ fn clear_check_notice(app: &AppHandle) {
 /// / kein Update / fehlgeschlagen mit Grund); nur der http-Fall bleibt
 /// gesperrt. Ein fehlgeschlagener Check war bisher vom Zustand "kein Update"
 /// nicht unterscheidbar (quick-260922-frg).
-fn spawn_version_check(app: AppHandle, server_url: String) {
+///
+/// `install_after`: der Klick auf "Auf Version … aktualisieren" installiert
+/// NICHT den abgelegten Stand, sondern prueft zuerst frisch und installiert
+/// genau, was diese Pruefung liefert. Grund (Nutzer, 29.09.2026: "Signatur-
+/// verifikation failed", danach Browser): die Download-Adresse
+/// `/desktop/download/<os>` liefert immer den AKTUELLEN Installer; ein
+/// Stunden alter Stand trug noch die Signatur der Vorversion, nach dem
+/// Server-Update passten Datei und Signatur nicht mehr zusammen.
+fn spawn_version_check(app: AppHandle, server_url: String, install_after: bool) {
     let update_item = app.state::<TrayItems>().update.clone();
     let _ = update_item.set_text(UPDATE_ITEM_CHECKING);
     let _ = update_item.set_enabled(false);
@@ -489,6 +497,11 @@ fn spawn_version_check(app: AppHandle, server_url: String) {
                 // das Plugin wendet `Update.timeout` als Gesamt-Timeout des
                 // Downloads an (updater.rs Z. 698-700).
                 update.timeout = Some(Duration::from_secs(600));
+                clear_check_notice(&app);
+                if install_after {
+                    spawn_update_install(app.clone(), update, menu_text);
+                    return;
+                }
                 let _ = app
                     .notification()
                     .builder()
@@ -500,7 +513,6 @@ fn spawn_version_check(app: AppHandle, server_url: String) {
                 if let Ok(mut pending) = app.state::<PendingUpdate>().0.lock() {
                     *pending = Some((update, menu_text));
                 }
-                clear_check_notice(&app);
             }
             Ok(None) => {
                 let _ = update_item.set_text(UPDATE_ITEM_NONE);
@@ -655,7 +667,7 @@ fn save_server_url(app: AppHandle, url: String) -> Result<(), String> {
     store.save().map_err(|e| e.to_string())?;
 
     apply_server(&app, Some(&normalized));
-    spawn_version_check(app.clone(), normalized.clone());
+    spawn_version_check(app.clone(), normalized.clone(), false);
 
     if let Some(window) = app.get_webview_window("main") {
         let _ = window.navigate(with_desktop_marker(&parsed));
@@ -868,27 +880,24 @@ pub fn run() {
                     }
                     "update" => {
                         // `take()` verhindert Doppelklick-Downloads, der
-                        // gesperrte Eintrag ebenso. Ohne abgelegten Stand
-                        // ("Kein Update verfügbar" / "Update-Prüfung
-                        // fehlgeschlagen") prueft der Klick erneut -- der
-                        // Browser-Weg (`open_download_page`) ist nur noch
-                        // Rueckfall einer fehlgeschlagenen Installation.
+                        // gesperrte Eintrag ebenso. Liegt ein Update vor,
+                        // wird es NICHT aus dem Speicher installiert, sondern
+                        // frisch geprueft und das Ergebnis installiert
+                        // (`install_after`, siehe spawn_version_check). Ohne
+                        // abgelegten Stand ("Kein Update verfügbar" /
+                        // "Update-Prüfung fehlgeschlagen") prueft der Klick
+                        // nur erneut. Der Browser-Weg (`open_download_page`)
+                        // bleibt Rueckfall einer fehlgeschlagenen Installation.
                         // Ohne gespeicherte Adresse gibt es nichts zu pruefen.
-                        let pending = app
+                        let had_pending = app
                             .state::<PendingUpdate>()
                             .0
                             .lock()
                             .ok()
-                            .and_then(|mut guard| guard.take());
-                        match pending {
-                            Some((update, menu_text)) => {
-                                spawn_update_install(app.clone(), update, menu_text)
-                            }
-                            None => {
-                                if let Some(url) = stored_server_url(app) {
-                                    spawn_version_check(app.clone(), url);
-                                }
-                            }
+                            .and_then(|mut guard| guard.take())
+                            .is_some();
+                        if let Some(url) = stored_server_url(app) {
+                            spawn_version_check(app.clone(), url, had_pending);
                         }
                     }
                     "autostart" => {
@@ -928,7 +937,7 @@ pub fn run() {
             apply_server(app.handle(), server_url.as_deref());
 
             if let Some(url) = server_url {
-                spawn_version_check(app.handle().clone(), url);
+                spawn_version_check(app.handle().clone(), url, false);
             }
 
             // Wiederholte Pruefung alle UPDATE_CHECK_INTERVAL. Bewusst ein
@@ -955,7 +964,7 @@ pub fn run() {
                     continue;
                 }
                 if let Some(url) = stored_server_url(&handle) {
-                    spawn_version_check(handle.clone(), url);
+                    spawn_version_check(handle.clone(), url, false);
                 }
             });