fix(v5): Das Update installierte nie — die eigene Leine erschlug den Installer

Commander: "Rippy wird zwar sauber beendet aber startet NICHT neu in der
neuen version."

Ursache, auf drei Beinen belegt:

1. Bibliothek: electron-updater startet den Installer per
   spawn(..., { detached: true }) (BaseUpdater.js, an der installierten
   Fassung nachgelesen). `detached` setzt unter Windows KEIN Breakaway.
2. Leine: leine.ts setzt KILL_ON_JOB_CLOSE, und Kinder erben die
   Mitgliedschaft. Der Installer war damit Mitglied der Arbeitsgruppe.
3. Platte: pending\RippySetup-5.1.3.exe lag geladen da (18:11:47),
   installiert war weiter 5.1.2. Der Download klappte, nur die
   Installation nicht.

Der Installer starb also in genau der Sekunde, in der Rippy sich
beendete, um ihm Platz zu machen.

Fix — die Leine bleibt, der Installer klinkt sich aus:

* leine.ts setzt zusaetzlich JOB_OBJECT_LIMIT_BREAKAWAY_OK. Das aendert
  fuer sich genommen NICHTS: Kinder erben weiter, ausser sie verlangen
  das Ausklinken selbst. Kern, makemkvcon und HandBrakeCLI bleiben
  angeleint, die rc10-Waisen-Falle (Paragraph 3.3) ist unveraendert zu.
* Neu: ausserhalbDerLeineStarten() startet EIN Programm per CreateProcessW
  mit CREATE_BREAKAWAY_FROM_JOB. Liegt in leine.ts, weil dort die
  Arbeitsgruppe verwaltet wird — und weil Waechter R1 koffi nur dort und
  in kern/laufwerk/win32.ts erlaubt.
* update.ts installiert jetzt SELBST: autoInstallOnAppQuit ist aus, der
  Installerpfad kommt aus downloadUpdate() (laut AppUpdater.d.ts "Paths to
  downloaded files"), die Argumente sind die von electron-updater
  gemessenen (--updated /S --force-run). Gestartet wird beim Beenden
  (will-quit) und ueber den Knopf.
* Neu kommandozeile.ts (pur, ohne koffi/Electron): CreateProcessW nimmt
  EINE Zeichenkette. Ohne die Regeln von CommandLineToArgvW zerfiele ein
  Pfad wie "C:\Users\Tobi Neu\..." in zwei Argumente.

BEWIESEN, nicht behauptet — neu: beweise/leine-breakaway.js

  OHNE Ausklinken (so macht es electron-updater)
    lebt nach dem Tod des Elternprozesses: NEIN  -> WIE ERWARTET
  MIT Ausklinken (so macht es Rippy ab 5.1.4)
    lebt nach dem Tod des Elternprozesses: JA    -> WIE ERWARTET

Der erste Messlauf zeigte ein falsches Negativ: Der Enkel starb an der
sterbenden KONSOLE des Elternprozesses, nicht an der Arbeitsgruppe. Erst
mit CREATE_NO_WINDOW (eigene Konsole) misst der Versuch, was er messen
soll. Diese Lehre steht als Kommentar im Code und der Flag ist auch im
echten Aufruf gesetzt.

237 Tests gruen (vorher 230), Typpruefung sauber. Version 5.1.4.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

rippy-windows/src/haupt/update.ts

@@ -15,6 +15,8 @@
 // Ladefortschritt, und JEDE Änderung meldet sich sofort ans Fenster.
 import { app } from 'electron'
 import electronUpdater from 'electron-updater'
+import { INSTALLER_ARGUMENTE } from './kommandozeile'
+import { ausserhalbDerLeineStarten } from './leine'
 import { neuerungenText, updateUrlPruefen } from './update-regeln'
 
 export {
@@ -46,6 +48,12 @@ let aenderungMelden: () => void = () => {
 }
 let ripLaeuftJetzt: () => boolean = () => false
 let scharf = false
+/** Der geladene Installer — leer, solange nichts bereitliegt. */
+let installerPfad = ''
+/** Einmal gestartet reicht: Der Knopf und der Beenden-Weg dürfen sich
+ *  nicht gegenseitig zwei Installer auf den Hals hetzen. */
+let installerGestartet = false
+let rippyBeenden: () => void = () => app.quit()
 
 export function updateStand(): UpdateStand {
   return { ...stand }
@@ -66,9 +74,11 @@ export function updateEinrichten(
   beiAenderung: () => void = () => {
     // ohne Fenster kein Empfänger — der Stand bleibt trotzdem abrufbar
   },
+  beenden: () => void = () => app.quit(),
 ): void {
   aenderungMelden = beiAenderung
   ripLaeuftJetzt = ripLaeuft
+  rippyBeenden = beenden
   if (!app.isPackaged) {
     setzen({ text: 'Entwicklungslauf — Selbst-Update ist nur im installierten Rippy aktiv.' })
     return
@@ -83,10 +93,24 @@ export function updateEinrichten(
     autoUpdater.setFeedURL({ provider: 'generic', url: eigeneUrl.trim() })
   }
   autoUpdater.autoDownload = false
-  // Installiert wird beim NÄCHSTEN Start — nie mitten in einem Rip.
-  autoUpdater.autoInstallOnAppQuit = true
+  // WIR installieren, nicht electron-updater (01.09.2026, am lebenden
+  // Objekt bezahlt): Sein eigener Weg startet den Installer per
+  // `spawn(…, { detached: true })`, und `detached` setzt unter Windows KEIN
+  // Breakaway. Der Installer wurde damit Mitglied der Prozess-Leine (§ 3.3)
+  // und starb in genau der Sekunde, in der Rippy sich für ihn beendete.
+  // Befund: „Rippy wird zwar sauber beendet aber startet NICHT neu."
+  autoUpdater.autoInstallOnAppQuit = false
   scharf = true
 
+  // Beim Beenden — egal ob über das Tray, den Update-Knopf oder das
+  // Herunterfahren von Windows — bekommt ein bereitliegendes Update noch
+  // seinen Start. CreateProcessW ist synchron: Der Installer LEBT, bevor
+  // diese Zeile zurückkommt.
+  app.on('will-quit', () => {
+    if (!stand.bereit || ripLaeuftJetzt()) return
+    installerAnwerfen()
+  })
+
   autoUpdater.on('update-available', (info) => {
     const neuerungen = neuerungenText(info.releaseNotes)
     if (ripLaeuft()) {
@@ -111,13 +135,24 @@ export function updateEinrichten(
     })
     // Der Commander wollte die Meldung sehen, nicht suchen müssen.
     melden(`Update verfügbar: Version ${info.version} wird geladen.`)
-    void autoUpdater.downloadUpdate().catch((fehler: unknown) => {
-      setzen({
-        laeuft: false,
-        fortschritt: -1,
-        text: `Update-Download fehlgeschlagen: ${String(fehler).slice(0, 160)}`,
+    void autoUpdater
+      .downloadUpdate()
+      .then((pfade: string[]) => {
+        // downloadUpdate liefert die abgelegten Dateien zurück
+        // (AppUpdater.d.ts: „Paths to downloaded files") — die .exe darin
+        // ist der Installer, den wir gleich selbst starten. Liegt die Datei
+        // vom letzten Lauf schon im Zwischenspeicher, kommt sie hier
+        // ebenfalls heraus, ohne erneut zu laden.
+        const exe = (pfade ?? []).find((p) => p.toLowerCase().endsWith('.exe')) ?? ''
+        if (exe.length > 0) installerPfad = exe
+      })
+      .catch((fehler: unknown) => {
+        setzen({
+          laeuft: false,
+          fortschritt: -1,
+          text: `Update-Download fehlgeschlagen: ${String(fehler).slice(0, 160)}`,
+        })
       })
-    })
   })
   autoUpdater.on('download-progress', (fortschritt) => {
     setzen({ laeuft: true, fortschritt: Math.round(fortschritt.percent) })
@@ -177,6 +212,22 @@ export function updatePruefenJetzt(): void {
   pruefen()
 }
 
+/** Den Installer AUSSERHALB der Prozess-Leine anwerfen. Gibt zurück, ob
+ *  er wirklich läuft — „nichts passiert" darf nicht als Erfolg durchgehen. */
+function installerAnwerfen(): { ok: boolean; grund: string } {
+  if (installerGestartet) return { ok: true, grund: '' }
+  if (installerPfad.length === 0) {
+    return { ok: false, grund: 'Es liegt kein geladener Installer bereit.' }
+  }
+  const urteil = ausserhalbDerLeineStarten(installerPfad, INSTALLER_ARGUMENTE)
+  if (!urteil.ok) {
+    setzen({ text: `Update konnte nicht gestartet werden: ${urteil.fehler}` })
+    return { ok: false, grund: urteil.fehler }
+  }
+  installerGestartet = true
+  return { ok: true, grund: '' }
+}
+
 /** Der Knopf „Jetzt neu starten und installieren". Nur sinnvoll, wenn
  *  wirklich etwas bereitliegt — und nie mitten in einem Rip. */
 export function updateInstallierenJetzt(): { ok: boolean; grund: string } {
@@ -186,8 +237,10 @@ export function updateInstallierenJetzt(): { ok: boolean; grund: string } {
   if (ripLaeuftJetzt()) {
     return { ok: false, grund: 'Erst wenn der Rip fertig ist — Rippy startet dafür neu (§ 6.8).' }
   }
-  // quitAndInstall schließt alle Fenster und beendet die App; der
-  // Installer läuft danach und startet Rippy wieder.
-  autoUpdater.quitAndInstall()
+  // Erst den Installer, DANN beenden: Er wartet von sich aus, bis Rippy
+  // weg ist, und startet es hinterher wieder (`--force-run`).
+  const urteil = installerAnwerfen()
+  if (!urteil.ok) return urteil
+  rippyBeenden()
   return { ok: true, grund: '' }
 }