hmgr 0.0.7 → 0.0.12

package/dist/gui/main.js

@@ -3,6 +3,9 @@
 // Fenster. Kein zweiter Prozess: der Kern läuft direkt im Main-Prozess, die GUI ist ein zweiter
 // Kompositions-Einstieg neben der CLI (ARCHITEKTUR.md „Eingang").
 import { app, BrowserWindow, dialog, ipcMain, Menu, shell } from 'electron';
+// electron-updater ist CommonJS: in ESM kommt nur der Default-Export an, `autoUpdater` wird aus ihm
+// herausgegriffen. Ein benannter Import (`import { autoUpdater } from …`) scheitert zur Laufzeit.
+import electronUpdater from 'electron-updater';
 import path from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { stat } from 'node:fs/promises';
@@ -17,6 +20,8 @@ import { entscheideOeffnen } from "./oeffnen.js";
 import { mcpUebernahmeSerialisieren, mcpUebersichtSerialisieren, mcpWirkungSerialisieren } from "./mcp-ansicht.js";
 import { beobachten } from "./beobachter.js";
 import { loginPathUebernehmen } from "./login-pfad.js";
+import { hmgrCliVersion } from "./hmgr-cli.js";
+import { cliUpdateHinweis } from "../adapter/npm-registry.js";
 const hierVerzeichnis = path.dirname(fileURLToPath(import.meta.url));
 const smoketest = process.env.HMGR_GUI_SMOKETEST === '1';
 /**
@@ -118,6 +123,18 @@ const { anwendungsfaelle, ports } = bauen(umgebung, {
     rueckfrage,
     ...(smoketest ? { claudeAusfuehrer: smoketestClaudeAusfuehrer } : {}),
 });
+/**
+ * Wer den laufenden Aktualisieren-Lauf ausgelöst hat (E80): der Renderer reicht es bei jedem Aufruf
+ * mit, hier gemerkt für die beiden hmgr-Selbstprüfungen (`update-downloaded`, `cliUpdatePruefen`),
+ * die selbst keinen eigenen Auslöser kennen. Default 'start', bevor der erste Lauf gemeldet hat.
+ */
+let letzterAusloeser = 'start';
+// Merkt die GUI-Version beim Start im Verlauf (E80): ein Versionssprung gegen den letzten Start
+// bekommt einen Eintrag „hmgr-GUI X installiert". Läuft auch im Smoke-Test — hmgrHome zeigt dort auf
+// ein Wegwerf-Verzeichnis (fixtureAufbauen in scripts/gui-smoke-test.ts), nie auf das echte ~/.hmgr.
+void anwendungsfaelle.versionsSprungVermerken('gui', paketVersion(), 'start').catch((fehler) => {
+    console.log(`[verlauf] ${fehler instanceof Error ? fehler.message : String(fehler)}`);
+});
 async function auffangen(fn) {
     await pathBereit; // erst der Login-PATH (F47=O2), dann der Adapter — sonst findet er die CLI nicht
     try {
@@ -296,7 +313,25 @@ function registriereIpc() {
         lokal: args.ort.art === 'arbeitsverzeichnis',
     })));
     ipcMain.handle('hmgr:eintragLoeschen', async (_event, args) => auffangen(async () => anwendungsfaelle.eintragLoeschen({ ziel: zielAusIpc(args.harness, args.ort), name: args.name })));
-    ipcMain.handle('hmgr:aktualisieren', async (_event, args) => auffangen(async () => anwendungsfaelle.aktualisieren(args)));
+    ipcMain.handle('hmgr:aktualisieren', async (_event, args) => auffangen(async () => {
+        if (args?.ausloeser !== undefined)
+            letzterAusloeser = args.ausloeser;
+        return anwendungsfaelle.aktualisieren(args);
+    }));
+    // Changelog der letzten Läufe (E80), neueste zuerst.
+    ipcMain.handle('hmgr:verlauf', async () => auffangen(async () => anwendungsfaelle.verlauf()));
+    // E77: der Prüfen-Knopf stößt zusätzlich zum Quellen-Lauf die Prüfung auf hmgr selbst an. Kein
+    // `handle`, sondern `send`/`on`: der Renderer wartet auf nichts, das Ergebnis kommt später von
+    // sich aus über 'hmgr:selbstUpdate'.
+    ipcMain.on('hmgr:selbstUpdatePruefen', () => selbstUpdatePruefen());
+    // Neustart-Knopf an der GUI-Update-Zeile (E80): installiert das geladene Paket sofort, statt auf
+    // das nächste Beenden zu warten. Im Smoke-Test ein No-op — dort läuft `updatePruefen` ohnehin nie,
+    // der Knopf bleibt verborgen, aber ein Absturz durch ein fehlendes Update darf trotzdem nie sein.
+    ipcMain.on('hmgr:neuStarten', () => {
+        if (smoketest)
+            return;
+        autoUpdater.quitAndInstall();
+    });
     ipcMain.handle('hmgr:arbeitsverzeichnisHinzufuegen', async (_event, pfad) => auffangen(async () => anwendungsfaelle.arbeitsverzeichnisHinzufuegen(pfad)));
     ipcMain.handle('hmgr:arbeitsverzeichnisVergessen', async (_event, pfad) => auffangen(async () => anwendungsfaelle.arbeitsverzeichnisVergessen(pfad)));
     // Nativer Verzeichnis-Dialog fürs Pfadfeld in „Verzeichnis hinzufügen" (A1). Im Smoke-Test darf
@@ -319,6 +354,14 @@ function registriereIpc() {
     ipcMain.handle('hmgr:harnessAktivieren', async (_event, name) => auffangen(async () => anwendungsfaelle.harnessAktivieren(name)));
     ipcMain.handle('hmgr:harnessDeaktivieren', async (_event, name) => auffangen(async () => anwendungsfaelle.harnessDeaktivieren(name)));
     ipcMain.handle('hmgr:saeubern', async (_event, name) => auffangen(async () => anwendungsfaelle.saeubern(name)));
+    // Homedirs je Harness (E78): zeigen, das primäre umstellen (F89), zusätzliche in einer
+    // WSL-Distro eintragen und vergessen (F87). Die Distro-Liste kommt aus `wsl -l -q`.
+    ipcMain.handle('hmgr:harnessHeime', async () => auffangen(async () => anwendungsfaelle.harnessHeime()));
+    ipcMain.handle('hmgr:wslDistros', async () => auffangen(async () => anwendungsfaelle.wslDistros()));
+    ipcMain.handle('hmgr:harnessHeimSetzen', async (_event, args) => auffangen(async () => anwendungsfaelle.harnessHeimSetzen(args.harness, args.pfad)));
+    ipcMain.handle('hmgr:harnessHeimZuruecksetzen', async (_event, harness) => auffangen(async () => anwendungsfaelle.harnessHeimZuruecksetzen(harness)));
+    ipcMain.handle('hmgr:harnessHeimHinzufuegen', async (_event, args) => auffangen(async () => anwendungsfaelle.harnessHeimHinzufuegen(args.harness, args.adresse)));
+    ipcMain.handle('hmgr:harnessHeimEntfernen', async (_event, args) => auffangen(async () => anwendungsfaelle.harnessHeimEntfernen(args.harness, args.adresse)));
     // Verwalteter Hermes-Skill-Ordner (E56): Zeigen kommt schon über hmgr:istZustand, hier nur Ändern.
     ipcMain.handle('hmgr:skillOrdnerFestlegen', async (_event, args) => auffangen(async () => anwendungsfaelle.skillOrdnerFestlegen(zielAusIpc(args.harness, args.ort), args.pfad)));
     ipcMain.handle('hmgr:skillOrdnerEntfernen', async (_event, args) => auffangen(async () => anwendungsfaelle.skillOrdnerEntfernen(zielAusIpc(args.harness, args.ort))));
@@ -474,6 +517,25 @@ function fensterOeffnen() {
               var harnessSchalter = Array.from(document.querySelectorAll('#harnessliste input[type=checkbox]'))
                 .map((i) => i.dataset.harness + ':' + i.checked)
                 .join(',');
+              // Homedir-Zeilen unter den Schaltern (E78): je Harness eine Zeile mit dem Pfad, dazu
+              // der Ändern-Knopf. Der Weg zu einem WSL-Homedir steht auf dem Mac bewusst nicht da.
+              var heimZeilen = Array.from(document.querySelectorAll('#harnessliste .heimzeile'))
+                .map((z) => z.textContent.replace(/\\s+/g, ' ').trim())
+                .join(' | ');
+              var heimWslKnopfVorhanden = Array.from(document.querySelectorAll('#harnessliste .heime > button'))
+                .some((b) => b.textContent.indexOf('WSL') !== -1);
+              // Der Pfad-Dialog lässt sich öffnen und per Abbrechen wieder schließen, ohne IPC-Lauf.
+              var heimPfadFehler = null;
+              var dHeimPfadOffenNachOeffnen = false;
+              var dHeimPfadOffenNachAbbrechen = true;
+              try {
+                document.querySelector('#harnessliste .heimknoepfe button')?.click();
+                dHeimPfadOffenNachOeffnen = document.getElementById('d-heim-pfad')?.open === true;
+                document.querySelector('#d-heim-pfad button[value="abbruch"]')?.click();
+                dHeimPfadOffenNachAbbrechen = document.getElementById('d-heim-pfad')?.open === true;
+              } catch (fehler) {
+                heimPfadFehler = String(fehler);
+              }
               // Quellen-Abschnitt der Einstellungen (E54): Knopf und Dialoge vorhanden, der
               // Hinzufügen-Dialog lässt sich öffnen und per Abbrechen ohne Fehler wieder schließen.
               // Kein echter Quellen-Lauf: der Abbrechen-Knopf löst keinen IPC-Aufruf aus.
@@ -534,6 +596,17 @@ function fensterOeffnen() {
               } catch (fehler) {
                 quelleUmbenennenFehler = String(fehler);
               }
+              // Leertext der Quellenliste (E75): der Smoke-Lauf hat immer eine Quelle, den leeren
+              // Zustand erreicht er nie. Geprüft wird darum die Regel, an der er zerbrach — ein
+              // <li class="leerhinweis"> in genau dieser Liste ist vom Grid ausgenommen und nimmt
+              // die ganze Breite, statt in die 20px-Icon-Spalte zu fallen und Wort für Wort
+              // umzubrechen. Die Probe wird sofort wieder entfernt, die Liste bleibt unberührt.
+              var quellenLeerProbe = document.createElement('li');
+              quellenLeerProbe.className = 'leerhinweis';
+              quellenLeerProbe.textContent = 'Probe';
+              document.getElementById('quellenliste')?.appendChild(quellenLeerProbe);
+              var quellenLeerDisplay = getComputedStyle(quellenLeerProbe).display;
+              quellenLeerProbe.remove();
               document.getElementById('d-einstellungen')?.close();
               // Konfigzeile am Hermes-Ziel (E56): der verwaltete Pfad steht in der Karte, auch
               // ungeklappt (hidden ändert textContent nicht). Dazu der Festlegen-Weg am unmanaged
@@ -553,6 +626,52 @@ function fensterOeffnen() {
               } catch (fehler) {
                 skillOrdnerFehler = String(fehler);
               }
+              // E77: der Ort für die Update-Hinweise steht in der Seitenleiste, direkt vor dem
+              // Einstellungen-Knopf, und ist im Ruhezustand leer und verborgen. Der Smoke-Lauf
+              // prüft nie nach — er stößt weder Updater noch CLI-Prüfung an, es gibt nichts zu
+              // melden. Geprüft wird darum nur, dass der Ort da ist und stumm bleibt.
+              var selbstupdateEl = document.getElementById('selbstupdate');
+              var selbstupdateVorhanden = selbstupdateEl !== null;
+              // Nicht nur das Attribut, sondern das tatsächliche Rendern: die Klasse setzt
+              // display:flex, und eine Autoren-Regel überstimmt das hidden-Attribut des Browsers —
+              // ohne die eigene hidden-Regel in styles.css stünde hier ein leerer Kasten samt
+              // seinem auto-Rand. Das Attribut allein würde den Fehler nicht zeigen.
+              var selbstupdateVerborgen =
+                selbstupdateEl?.hidden === true && getComputedStyle(selbstupdateEl).display === 'none';
+              // Seit E80 steckt im Kasten auch der Neustart-Knopf, sein Text bleibt aber im DOM
+              // stehen, auch verborgen (anders als bei display:none zählt hidden nicht für
+              // textContent) — „leer" meint deshalb: kein sichtbarer (nicht verborgener) Kindknoten
+              // trägt Text, nicht der rohe textContent des ganzen Kastens.
+              var selbstupdateLeer = Array.from(selbstupdateEl?.children ?? [])
+                .filter((kind) => !kind.hidden)
+                .every((kind) => (kind.textContent ?? '').trim() === '');
+              // Er sitzt zwischen Stand-Zeile und Einstellungen-Knopf: der Knopf ist sein nächster
+              // Geschwister-Knoten, sonst stünde der Hinweis irgendwo anders in der Leiste.
+              var selbstupdateVorEinstellungen = selbstupdateEl?.nextElementSibling?.id === 'einstellungen';
+              // E80: Neustart-Knopf an der GUI-Update-Zeile, vorhanden und im Ruhezustand verborgen
+              // (der Smoke-Lauf löst nie ein update-downloaded aus, das ihn einblenden würde).
+              var selbstupdateNeustartVorhanden = document.getElementById('selbstupdate-neustart') !== null;
+              var selbstupdateNeustartVerborgen = document.getElementById('selbstupdate-neustart')?.hidden === true;
+              // E80: die Seitenleiste zeigt nur noch die Stand-Zeile und ein „›" zum Öffnen der
+              // Ansicht, kein „Prüfen"-Wort mehr und kein eigener Lauf am Standknopf-Klick. In der
+              // Ansicht selbst ersetzt ein runder Kringel den früheren großen Knopf, und der alte
+              // Sitzungsbericht (#bericht) ist ganz weg, ersetzt durch das Changelog (#verlauf).
+              var standknopfText = document.getElementById('standknopf')?.textContent ?? null;
+              var updatestartKringel = document.getElementById('updatestart')?.classList.contains('kringel') === true;
+              var updatestartLaeuft = document.getElementById('updatestart')?.classList.contains('laeuft') === true;
+              var berichtVorhanden = document.getElementById('bericht') !== null;
+              var verlaufVorhanden = document.getElementById('verlauf') !== null;
+              // Der Standknopf öffnet nur noch die Ansicht (kein Lauf mehr an diesem Klick), die
+              // Ansicht lädt ihren Verlauf dabei aus der Datei — das ist ein IPC-Aufruf, also kurz
+              // nachfassen, bis das Ergebnis im DOM steht (Muster wie bei mcpWahlOeffnen oben).
+              document.getElementById('standknopf')?.click();
+              var verlaufBloecke = 0;
+              for (var wartezeit = 0; wartezeit < 2000; wartezeit += 100) {
+                await new Promise((r) => setTimeout(r, 100));
+                verlaufBloecke = document.querySelectorAll('#verlauf .block').length;
+                if (verlaufBloecke > 0) break;
+              }
+              var verlaufText = document.getElementById('verlauf')?.textContent?.replace(/\\s+/g, ' ').trim() ?? null;
               // E60: Beschreibung in der Ziel-Tabelle (nicht nur im Katalog), „manuell" entfällt,
               // Zahnrad statt Sonne am Einstellungen-Knopf.
               var zielBeschreibung = document.querySelector('#zielliste .linkliste .was')?.textContent ?? null;
@@ -567,6 +686,57 @@ function fensterOeffnen() {
               // E70/F70=O1: die Herkunftszeile trägt hinter dem Ref das Änderungsdatum des Skills.
               var katalogHerkunft = document.querySelector('#katalog .zeile .herkunft')?.textContent
                 ?.replace(/\\s+/g, ' ').trim() ?? null;
+              // E79: Sortier-Gruppe der Skills-Rubrik. Erst „Zuletzt geändert" klicken und die
+              // sichtbaren Änderungsdaten der ersten fünf Zeilen samt Knopfstand festhalten, dann
+              // zurück auf „Name", damit die obigen Prüfungen (erste Zeile) unverändert gelten.
+              document.getElementById('sortnach-datum')?.click();
+              var katalogSortierungGeaendert = Array.from(document.querySelectorAll('#katalog .zeile:not([hidden])'))
+                .slice(0, 5)
+                .map((li) => li.dataset.geaendert ?? '')
+                .join('|');
+              var katalogSortierungDatumGedrueckt = document.getElementById('sortnach-datum')?.getAttribute('aria-pressed') ?? null;
+              var katalogSortierungNameGedrueckt = document.getElementById('sortnach-name')?.getAttribute('aria-pressed') ?? null;
+              // E81: Richtung und Pfeil nach dem ersten Klick. Standardrichtung von „datum" ist
+              // 'ab' (jüngste zuerst, wie E79), der Name-Chip ist dabei inaktiv und trägt keinen
+              // Pfeil.
+              var katalogSortierungDatumRichtung = document.getElementById('sortnach-datum')?.getAttribute('data-richtung') ?? null;
+              var katalogSortierungDatumPfeil = document.querySelector('#sortnach-datum .sortpfeil')?.textContent ?? null;
+              var katalogSortierungNamePfeil = document.querySelector('#sortnach-name .sortpfeil')?.textContent ?? null;
+              // E81: zweiter Klick auf denselben Chip kehrt nur die Richtung um (Schlüssel bleibt
+              // „datum", jetzt älteste zuerst).
+              document.getElementById('sortnach-datum')?.click();
+              var katalogSortierungGeaendertAuf = Array.from(document.querySelectorAll('#katalog .zeile:not([hidden])'))
+                .slice(0, 5)
+                .map((li) => li.dataset.geaendert ?? '')
+                .join('|');
+              var katalogSortierungDatumRichtungAuf = document.getElementById('sortnach-datum')?.getAttribute('data-richtung') ?? null;
+              var katalogSortierungDatumPfeilAuf = document.querySelector('#sortnach-datum .sortpfeil')?.textContent ?? null;
+              document.getElementById('sortnach-name')?.click();
+              // Reiner Textknoten des Namens (erstes Kind ist das Quellen-Icon, ein etwaiges
+              // Markenfeld käme als weiteres Element danach) statt h3.textContent, sonst würde
+              // eine Marke direkt an den Namen geklebt.
+              var ersterKatalogH3 = document.querySelector('#katalog .zeile:not([hidden]) h3');
+              var katalogErsterNachName = ersterKatalogH3
+                ? Array.from(ersterKatalogH3.childNodes).find((n) => n.nodeType === 3)?.textContent ?? null
+                : null;
+              // E81: Chipwechsel (anderer Schlüssel als zuvor „datum") setzt dessen Standardrichtung,
+              // hier 'auf' für Name — die bisherige, unveränderte Reihenfolge (A→Z).
+              var katalogNamenAuf = Array.from(document.querySelectorAll('#katalog .zeile:not([hidden]) h3'))
+                .map((h3) => Array.from(h3.childNodes).find((n) => n.nodeType === 3)?.textContent ?? '')
+                .join('|');
+              var katalogSortierungNameRichtungAuf = document.getElementById('sortnach-name')?.getAttribute('data-richtung') ?? null;
+              var katalogSortierungNamePfeilAuf = document.querySelector('#sortnach-name .sortpfeil')?.textContent ?? null;
+              // E81: zweiter Klick auf „Name" kehrt die Richtung um (Z→A).
+              document.getElementById('sortnach-name')?.click();
+              var katalogNamenAb = Array.from(document.querySelectorAll('#katalog .zeile:not([hidden]) h3'))
+                .map((h3) => Array.from(h3.childNodes).find((n) => n.nodeType === 3)?.textContent ?? '')
+                .join('|');
+              var katalogSortierungNameRichtungAb = document.getElementById('sortnach-name')?.getAttribute('data-richtung') ?? null;
+              var katalogSortierungNamePfeilAb = document.querySelector('#sortnach-name .sortpfeil')?.textContent ?? null;
+              // E81: dritter Klick stellt name/auf wieder her, damit die restliche Sonde (unten)
+              // wie gewohnt gegen die Standardsortierung prüft.
+              document.getElementById('sortnach-name')?.click();
+              var katalogSortierungNameRichtungNachDrittemKlick = document.getElementById('sortnach-name')?.getAttribute('data-richtung') ?? null;
               // Besonderheiten aus dem Frontmatter (E55): Marken an der Zeile, Details erst nach
               // einem Klick auf den Aufklapp-Knopf.
               var katalogMarken = document.querySelector('#katalog .zeile .marken')?.textContent
@@ -597,6 +767,17 @@ function fensterOeffnen() {
                   ?.replace(/\\s+/g, ' ').trim() ?? null;
                 document.getElementById('d-skills')?.close();
               }
+              // Verlinken-Dialog „Wohin?" (E76): er bietet nur Ziele aktiver Harnesses an. Der Text
+              // der Wahlliste sagt, welche das sind; ist gar keines aktiv, steht dort der Leerhinweis.
+              var dzZieleText = null;
+              var dzKnopf = Array.from(document.querySelectorAll('#katalog .zeile button'))
+                .find((b) => b.textContent === 'Verlinken');
+              if (dzKnopf) {
+                dzKnopf.click();
+                dzZieleText = document.getElementById('dz-ziele')?.textContent
+                  ?.replace(/\\s+/g, ' ').trim() ?? null;
+                document.getElementById('d-ziel')?.close();
+              }
               // Bundle-Gruppe an der Ziel-Karte (E69): Kopf mit Name, Quelle und Entfernen, darunter
               // die Zeilen der Mitglieder — sie stehen in der Gruppe, nicht in der allgemeinen Liste.
               var bundleGruppeText = document.querySelector('#zielliste .bundlegruppe .bundlekopf')?.textContent
@@ -736,6 +917,19 @@ function fensterOeffnen() {
               var agentsKarteVorhanden = agentsKarte !== undefined;
               var agentsMcpAbschnittVorhanden = (agentsKarte?.querySelector('.mcpkarteabschnitt') ?? null) !== null;
               var agentsMcpKnopfVorhanden = mcpHinzuKnopfAn(agentsKarte) !== undefined;
+              // Warnzahl am Kartenkopf (E75): das Dreieck nennt die Zahl der Auslöser. Im Fixture
+              // liegt ein fremder Ordner im Hermes-Home-Ziel (1) und drei im Verzeichnis kunde-x,
+              // ungleich auf die zwei Harness-Teile verteilt — dort ist die Zahl die Summe. Die
+              // agents-Karte hat keinen Auslöser und darum gar kein Dreieck.
+              var warnungVon = function (karte) { return karte?.querySelector('.zielkopf .warnung') ?? null; };
+              var warnzahlVon = function (karte) {
+                return warnungVon(karte)?.querySelector('.warnzahl')?.textContent?.trim() ?? null;
+              };
+              var hermesWarnzahl = warnzahlVon(hermesKarte);
+              var hermesWarnlabel = warnungVon(hermesKarte)?.getAttribute('aria-label') ?? null;
+              var kundeXWarnzahl = warnzahlVon(kundeXKarte);
+              var kundeXWarnlabel = warnungVon(kundeXKarte)?.getAttribute('aria-label') ?? null;
+              var agentsWarnungVorhanden = warnungVon(agentsKarte) !== null;
               // Dialog „MCP hinzufügen" (E47-Muster): öffnen an der Hermes-Karte und über Abbrechen
               // wieder schließen, ohne IPC-Schreibaktion (mcpEinhaengen liefe erst nach „Einhängen").
               var dmhFehler = null;
@@ -763,12 +957,34 @@ function fensterOeffnen() {
                 meldung: document.getElementById('meldungtext')?.textContent,
                 einstellungenOffen,
                 harnessSchalter,
+                heimZeilen,
+                heimWslKnopfVorhanden,
+                heimPfadFehler,
+                dHeimPfadOffenNachOeffnen,
+                dHeimPfadOffenNachAbbrechen,
                 zielBeschreibung,
                 zielMarken,
                 zielManuellVorhanden,
                 zahnradVorhanden,
                 katalogBeschreibung,
                 katalogHerkunft,
+                katalogSortierungGeaendert,
+                katalogSortierungDatumGedrueckt,
+                katalogSortierungNameGedrueckt,
+                katalogSortierungDatumRichtung,
+                katalogSortierungDatumPfeil,
+                katalogSortierungNamePfeil,
+                katalogSortierungGeaendertAuf,
+                katalogSortierungDatumRichtungAuf,
+                katalogSortierungDatumPfeilAuf,
+                katalogErsterNachName,
+                katalogNamenAuf,
+                katalogSortierungNameRichtungAuf,
+                katalogSortierungNamePfeilAuf,
+                katalogNamenAb,
+                katalogSortierungNameRichtungAb,
+                katalogSortierungNamePfeilAb,
+                katalogSortierungNameRichtungNachDrittemKlick,
                 katalogMarken,
                 katalogDetailsZu,
                 katalogAufgeklappt,
@@ -777,6 +993,7 @@ function fensterOeffnen() {
                 dskMarken,
                 dskBundleBoxSichtbar,
                 dskBundleText,
+                dzZieleText,
                 bundleGruppeText,
                 bundleGruppeZeilen,
                 bundleZerbrichtText,
@@ -831,6 +1048,12 @@ function fensterOeffnen() {
                 kundeXMcpKnopfVorhanden,
                 kundeXKopfZahl,
                 hermesKopfZahl,
+                hermesWarnzahl,
+                hermesWarnlabel,
+                kundeXWarnzahl,
+                kundeXWarnlabel,
+                agentsWarnungVorhanden,
+                quellenLeerDisplay,
                 agentsKarteVorhanden,
                 agentsMcpAbschnittVorhanden,
                 agentsMcpKnopfVorhanden,
@@ -838,6 +1061,19 @@ function fensterOeffnen() {
                 dMcpHinzuOffenNachAbbrechen,
                 dmhListeText,
                 dmhFehler,
+                selbstupdateVorhanden,
+                selbstupdateVerborgen,
+                selbstupdateLeer,
+                selbstupdateVorEinstellungen,
+                selbstupdateNeustartVorhanden,
+                selbstupdateNeustartVerborgen,
+                standknopfText,
+                updatestartKringel,
+                updatestartLaeuft,
+                berichtVorhanden,
+                verlaufVorhanden,
+                verlaufText,
+                verlaufBloecke,
               });
             })()`)
                     .then((auszug) => console.log(`[smoke] DOM-Auszug: ${auszug}`))
@@ -850,13 +1086,14 @@ function fensterOeffnen() {
     }
     // Selbsttätiges Aktualisieren (E44): einmal, sobald der Renderer bereit ist, danach alle sechs
     // Stunden, solange das Fenster offen bleibt. Im Smoke-Test nie, sonst würde ein automatisierter
-    // Lauf einen echten Git-Fetch anstoßen.
+    // Lauf einen echten Git-Fetch anstoßen. Der Auslöser (E80) geht mit, damit der Verlauf zeigt, ob
+    // ein Fund vom Start, vom Intervall oder einem Klick kam.
     if (!smoketest) {
         const fenster = hauptfenster;
         fenster.webContents.once('did-finish-load', () => {
-            fenster.webContents.send('hmgr:aktualisierenAnstossen');
+            fenster.webContents.send('hmgr:aktualisierenAnstossen', 'start');
         });
-        const intervall = setInterval(() => fenster.webContents.send('hmgr:aktualisierenAnstossen'), SECHS_STUNDEN_MS);
+        const intervall = setInterval(() => fenster.webContents.send('hmgr:aktualisierenAnstossen', 'intervall'), SECHS_STUNDEN_MS);
         fenster.on('closed', () => clearInterval(intervall));
     }
     // Die GUI erfährt von Änderungen außerhalb ihrer selbst (E62): Fokus-Reload und Datei-Watcher.
@@ -878,6 +1115,107 @@ function fensterOeffnen() {
     }
     void hauptfenster.loadFile(path.join(hierVerzeichnis, 'renderer', 'index.html'));
 }
+const { autoUpdater } = electronUpdater;
+/** Die Listener hängen am Modul, nicht am Aufruf: `updatePruefen` läuft beim Start und je Prüfen-Klick. */
+let updaterVerdrahtet = false;
+/**
+ * Autoupdate der Windows-GUI (E73). Der Feed sind die Gitea-Releases des hmgr-Repos: die
+ * `publish`-Angabe im build-Block der package.json erzeugt beim Bauen die `latest.yml` und legt
+ * `app-update.yml` ins Paket, aus der electron-updater die Feed-URL liest.
+ *
+ * `checkForUpdatesAndNotify()` heißt: im Hintergrund prüfen, ein gefundenes Update herunterladen,
+ * eine Windows-Benachrichtigung zeigen und beim Beenden der App installieren
+ * (`autoInstallOnAppQuit` ist Vorgabe). Das Einspielen bleibt damit der App-Neustart; die GUI zeigt
+ * seit E77 zusätzlich eine Zeile in der Sidebar, sobald das Paket geladen ist (`update-downloaded`).
+ *
+ * Drei Bedingungen, alle nötig:
+ * — `app.isPackaged`: ungepackt gibt es keine `app-update.yml`, die Prüfung stiege ohnehin aus.
+ * — `win32`: macOS lehnt electron-updater unsigniert ab, das wartet auf die Signierung (A4).
+ * — kein Smoke-Test: dieselbe Zurückhaltung wie bei Watcher und Auto-Aktualisieren — ein
+ *   automatisierter Lauf greift nie ins Netz.
+ *
+ * Fehler werden nur vermerkt, nie weitergereicht: auf den Team-Rechnern kann das Gitea unerreichbar
+ * sein (VPN, Abschaltung, DNS), und daran darf die App nicht scheitern. Der `error`-Listener ist
+ * dabei nicht optional — electron-updater meldet Fehler als Event, und ein `error`-Event ohne
+ * Zuhörer wirft in Node.
+ */
+function updatePruefen() {
+    if (smoketest || !app.isPackaged || process.platform !== 'win32')
+        return;
+    try {
+        if (!updaterVerdrahtet) {
+            updaterVerdrahtet = true;
+            autoUpdater.on('error', (fehler) => {
+                console.log(`[updater] ${fehler instanceof Error ? fehler.message : String(fehler)}`);
+            });
+            // E77: das geladene Paket wird sichtbar, seit E80 mit Neustart-Knopf. Zusätzlich ein
+            // Verlaufseintrag „GUI-Update X geladen" (E80), einmal je neuer Version — vor der Meldung an
+            // die Sidebar, damit die Ansicht ihn beim nächsten `ladeVerlauf()` schon findet.
+            autoUpdater.on('update-downloaded', (info) => {
+                const version = info?.version;
+                const guiVersion = typeof version === 'string' ? version : paketVersion();
+                void anwendungsfaelle
+                    .hmgrEreignisVermerken({ art: 'gui-update-geladen', version: guiVersion }, letzterAusloeser)
+                    .catch((fehler) => {
+                    console.log(`[verlauf] ${fehler instanceof Error ? fehler.message : String(fehler)}`);
+                });
+                selbstUpdateMelden({ art: 'gui', version: guiVersion });
+            });
+        }
+        void autoUpdater.checkForUpdatesAndNotify().catch((fehler) => {
+            console.log(`[updater] ${fehler instanceof Error ? fehler.message : String(fehler)}`);
+        });
+    }
+    catch (fehler) {
+        console.log(`[updater] ${fehler instanceof Error ? fehler.message : String(fehler)}`);
+    }
+}
+/** Ein Hinweis für die Sidebar (E77). Ist das Fenster schon zu, verfällt er stillschweigend. */
+function selbstUpdateMelden(nachricht) {
+    if (hauptfenster === null || hauptfenster.isDestroyed())
+        return;
+    hauptfenster.webContents.send('hmgr:selbstUpdate', nachricht);
+}
+/**
+ * Die daneben installierte hmgr-CLI gegen npm (E77, F83=O1). Läuft auf allen Plattformen — anders
+ * als die GUI-Prüfung hängt sie an keinem Paket-Format und an keiner Signierung. Gemeldet wird nur,
+ * nie installiert: ein `npm install -g` aus der App scheitert leicht an nvm-Pfaden und Rechten
+ * (F82).
+ *
+ * Still bei allem, was schiefgehen kann: keine CLI im PATH, Fehlercode, Registry unerreichbar,
+ * gleiche oder ältere Version auf npm. Der Login-PATH (F47) muss vorher stehen, sonst findet der
+ * Aufruf die per nvm installierte CLI nicht.
+ */
+async function cliUpdatePruefen() {
+    await pathBereit;
+    const installiert = await hmgrCliVersion();
+    if (installiert === null)
+        return;
+    const hinweis = await cliUpdateHinweis(installiert, { protokoll: (zeile) => console.log(zeile) });
+    if (hinweis === null)
+        return;
+    // Verlaufseintrag „CLI X verfügbar" (E80), einmal je neuer Version, vor der Sidebar-Meldung.
+    await anwendungsfaelle
+        .hmgrEreignisVermerken({ art: 'cli-verfuegbar', version: hinweis.neu }, letzterAusloeser)
+        .catch((fehler) => {
+        console.log(`[verlauf] ${fehler instanceof Error ? fehler.message : String(fehler)}`);
+    });
+    selbstUpdateMelden({ art: 'cli', ...hinweis });
+}
+/**
+ * Jeder Aktualisieren-Lauf prüft auch hmgr selbst (E80: Start, Intervall, Klick auf den Kringel) —
+ * der Renderer ruft das aus `aktualisierenLauf`, unabhängig vom Auslöser. Beide Wege sind
+ * unabhängig: die GUI-Prüfung gilt nur unter den E73-Bedingungen, die CLI-Prüfung überall. Im
+ * Smoke-Test unterbleiben beide — kein Spawn, kein Netz.
+ */
+function selbstUpdatePruefen() {
+    if (smoketest)
+        return;
+    updatePruefen();
+    void cliUpdatePruefen().catch((fehler) => {
+        console.log(`[cli-update] ${fehler instanceof Error ? fehler.message : String(fehler)}`);
+    });
+}
 /**
  * Holt das vorhandene Fenster nach vorn — die Antwort der laufenden Instanz auf einen zweiten
  * Start (E67). Minimiert kommt es erst wieder hoch, dann bekommt es den Fokus.
@@ -912,6 +1250,8 @@ if (einzelinstanz) {
             Menu.setApplicationMenu(null);
         }
         fensterOeffnen();
+        // Seit E80 prüft schon der erste Aktualisieren-Lauf (Renderer, ausgelöst bei `did-finish-load`)
+        // auch hmgr selbst über `selbstUpdatePruefen` — ein eigener Start-Aufruf hier wäre der zweite.
         app.on('activate', () => {
             if (BrowserWindow.getAllWindows().length === 0)
                 fensterOeffnen();

package/dist/gui/preload.cjs

@@ -33,6 +33,12 @@ contextBridge.exposeInMainWorld('hmgr', {
     eintragLoeschen: (args) => ipcRenderer.invoke('hmgr:eintragLoeschen', args),
     uebernehmen: (args) => ipcRenderer.invoke('hmgr:uebernehmen', args),
     aktualisieren: (args) => ipcRenderer.invoke('hmgr:aktualisieren', args),
+    /** Changelog der letzten Läufe (E80), neueste zuerst. */
+    verlauf: () => ipcRenderer.invoke('hmgr:verlauf'),
+    /** Installiert das geladene GUI-Update und startet neu (E80), Gegenstück zum Neustart-Knopf. */
+    neuStarten: () => {
+        ipcRenderer.send('hmgr:neuStarten');
+    },
     arbeitsverzeichnisHinzufuegen: (pfad) => ipcRenderer.invoke('hmgr:arbeitsverzeichnisHinzufuegen', pfad),
     arbeitsverzeichnisVergessen: (pfad) => ipcRenderer.invoke('hmgr:arbeitsverzeichnisVergessen', pfad),
     /** Nativer Verzeichnis-Dialog fürs Pfadfeld in „Verzeichnis hinzufügen" (A1). */
@@ -43,6 +49,13 @@ contextBridge.exposeInMainWorld('hmgr', {
     harnessAktivieren: (name) => ipcRenderer.invoke('hmgr:harnessAktivieren', name),
     harnessDeaktivieren: (name) => ipcRenderer.invoke('hmgr:harnessDeaktivieren', name),
     saeubern: (name) => ipcRenderer.invoke('hmgr:saeubern', name),
+    /** Homedirs je Harness (E78): zeigen, umstellen (F89), zusätzliche eintragen und vergessen (F87). */
+    harnessHeime: () => ipcRenderer.invoke('hmgr:harnessHeime'),
+    wslDistros: () => ipcRenderer.invoke('hmgr:wslDistros'),
+    harnessHeimSetzen: (args) => ipcRenderer.invoke('hmgr:harnessHeimSetzen', args),
+    harnessHeimZuruecksetzen: (harness) => ipcRenderer.invoke('hmgr:harnessHeimZuruecksetzen', harness),
+    harnessHeimHinzufuegen: (args) => ipcRenderer.invoke('hmgr:harnessHeimHinzufuegen', args),
+    harnessHeimEntfernen: (args) => ipcRenderer.invoke('hmgr:harnessHeimEntfernen', args),
     /** Verwalteter Hermes-Skill-Ordner (E56): zeigen kommt über hmgr:istZustand, hier nur Ändern. */
     skillOrdnerFestlegen: (args) => ipcRenderer.invoke('hmgr:skillOrdnerFestlegen', args),
     skillOrdnerEntfernen: (args) => ipcRenderer.invoke('hmgr:skillOrdnerEntfernen', args),
@@ -54,15 +67,26 @@ contextBridge.exposeInMainWorld('hmgr', {
     antwortenRueckfrage: (id, antwort) => {
         ipcRenderer.send('hmgr:rueckfrage:antwort', { id, antwort });
     },
-    /** Anstoß zum selbsttätigen Aktualisieren (E44): Main ruft nach dem Start und alle sechs Stunden. */
+    /** Anstoß zum selbsttätigen Aktualisieren (E44): Main ruft nach dem Start und alle sechs Stunden,
+        mit dem Auslöser für den Verlauf (E80). */
     onAktualisierenAnstossen: (hoerer) => {
-        ipcRenderer.on('hmgr:aktualisierenAnstossen', () => hoerer());
+        ipcRenderer.on('hmgr:aktualisierenAnstossen', (_event, ausloeser) => hoerer(ausloeser));
     },
     /** Anstoß zum stillen Neuladen der Anzeige (E62): Main ruft bei Fokus-Wechsel und beobachteten
         Dateiänderungen, nie mit Netzzugriff (im Unterschied zu onAktualisierenAnstossen). */
     onNeuLadenAnstossen: (hoerer) => {
         ipcRenderer.on('hmgr:neuLadenAnstossen', () => hoerer());
     },
+    /** Prüfung auf neue hmgr-Stände (E77), angestoßen bei jedem Aktualisieren-Lauf (E80: Start,
+        Intervall, Klick). Antwortet nicht, meldet sich später über onSelbstUpdate — Netz und Spawn
+        dauern länger als ein Knopfdruck. */
+    selbstUpdatePruefen: () => {
+        ipcRenderer.send('hmgr:selbstUpdatePruefen');
+    },
+    /** Ein Fund der Selbst-Prüfung (E77): geladenes GUI-Update oder neuere CLI auf npm. */
+    onSelbstUpdate: (hoerer) => {
+        ipcRenderer.on('hmgr:selbstUpdate', (_event, nachricht) => hoerer(nachricht));
+    },
     /** MCP-Ansicht (E61-Folgerunde): Katalog gelesen, nie geschrieben. */
     mcpUebersicht: () => ipcRenderer.invoke('hmgr:mcpUebersicht'),
     /** Plätze für den Einhängen-Dialog (F42): kommt aus dem Kern, hängt an der Fähigkeit (E16). */