hmgr 0.0.6 → 0.0.12

package/dist/gui/main.js

@@ -3,12 +3,16 @@
 // 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';
 import { fileURLToPath } from 'node:url';
 import { bauen, umgebungLesen } from "../cli/main.js";
 import { quelleAlsText, quelleAusText } from "../adapter/quelle-text.js";
+import { paketVersion } from "../adapter/paket-version.js";
 import { quelleName, quelleSchluessel } from "../kern/modell.js";
 import { kannProfile } from "../ports/harness.js";
 import { iconFuerQuelle } from "./icons.js";
@@ -16,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';
 /**
@@ -117,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 {
@@ -136,6 +154,14 @@ function zielZustandSerialisieren(z) {
         gruende: Object.fromEntries(z.gruende),
         ignoriert: z.ignoriert,
         uebernahme: Object.fromEntries(z.uebernahme),
+        // Bundles des Ziels (E69): Adresse und Anzeigename der Quelle kommen mit, damit der Renderer
+        // die Gruppe beschriften kann, ohne die Quelle selbst nachzuschlagen.
+        bundles: z.bundles.map((b) => ({
+            name: b.name,
+            skills: b.skills,
+            quelleText: quelleAlsText(b.quelle),
+            quelleName: quelleName(b.quelle),
+        })),
         istRegistriert: z.istRegistriert,
         kannSkillOrdner: z.kannSkillOrdner,
         ...(z.plugins === undefined ? {} : { plugins: z.plugins }),
@@ -181,6 +207,7 @@ function registriereIpc() {
                     ...(skill.modell === undefined ? {} : { modell: skill.modell }),
                     ...(skill.eigenerKontext === undefined ? {} : { eigenerKontext: skill.eigenerKontext }),
                     ...(skill.argumentHinweis === undefined ? {} : { argumentHinweis: skill.argumentHinweis }),
+                    ...(skill.geaendert === undefined ? {} : { geaendert: skill.geaendert }),
                     quelleText: quelleAlsText(eintrag.quelle),
                     quelleName: quelleName(eintrag.quelle),
                     quelleSchluessel: quelleSchluessel(eintrag.quelle),
@@ -189,6 +216,45 @@ function registriereIpc() {
         }
         return ergebnis;
     }));
+    // Bundles aller bekannten Quellen (E69): flach wie der Skill-Katalog, je Bundle seine Quelle und
+    // die Zahl seiner Mitglieder. Kaputte Definitionen kommen als eigene Liste mit, damit die GUI sie
+    // nennen kann, statt sie zu verschlucken.
+    ipcMain.handle('hmgr:bundles', async () => auffangen(async () => {
+        const bundles = [];
+        const kaputte = [];
+        for (const eintrag of await anwendungsfaelle.bundleKatalog()) {
+            for (const bundle of eintrag.bundles)
+                bundles.push({
+                    name: bundle.name,
+                    beschreibung: bundle.beschreibung,
+                    mitglieder: bundle.mitglieder.length,
+                    // Anzeige im Dialog: aus welchen Quellen das Bundle Skills holt, ohne Dubletten.
+                    quellen: [...new Set(bundle.mitglieder.map((m) => quelleAlsText(m.quelle)))],
+                    quelleText: quelleAlsText(bundle.quelle),
+                    quelleName: quelleName(bundle.quelle),
+                });
+            for (const kaputt of eintrag.kaputte)
+                kaputte.push({ quelleName: quelleName(eintrag.quelle), datei: kaputt.datei, fehler: kaputt.fehler });
+        }
+        return { bundles, kaputte };
+    }));
+    // Installieren und Entfernen wirken auf das Bundle als Ganzes (E69). Der Zeiger ist nicht im
+    // Spiel, die Zugehörigkeit steht im Zustand — anders als bei linkLegen braucht es kein `lokal`.
+    ipcMain.handle('hmgr:bundleInstallieren', async (_event, args) => auffangen(async () => {
+        const ergebnis = await anwendungsfaelle.bundleInstallieren({
+            bundle: args.bundle,
+            ziel: zielAusIpc(args.harness, args.ort),
+            ...(args.quelle === undefined ? {} : { quelle: args.quelle }),
+        });
+        return {
+            name: ergebnis.bundle.name,
+            gelegt: ergebnis.gelegt,
+            uebernommen: ergebnis.uebernommen,
+            neueQuellen: ergebnis.neueQuellen.map((q) => quelleName(q)),
+            ...(ergebnis.hinweis === undefined ? {} : { hinweis: ergebnis.hinweis }),
+        };
+    }));
+    ipcMain.handle('hmgr:bundleEntfernen', async (_event, args) => auffangen(async () => anwendungsfaelle.bundleEntfernen({ bundle: args.bundle, ziel: zielAusIpc(args.harness, args.ort) })));
     // Nur die Herkunft, ohne die Quellen zu lesen: der Katalog daneben tut das schon.
     ipcMain.handle('hmgr:quellen', async () => auffangen(async () => (await anwendungsfaelle.quellen()).map((quelle) => ({
         art: quelle.art,
@@ -247,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
@@ -270,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))));
@@ -386,6 +478,11 @@ function fensterOeffnen() {
         minWidth: 860,
         minHeight: 560,
         backgroundColor: '#E3E7E0', // --platte, verhindert einen weißen Blitz beim Start
+        // E72: der Fenstertitel nennt die Version, damit im Feld erkennbar ist, welcher Stand läuft.
+        // Nicht `app.getVersion()`: das liefert nur im gepackten Bundle die Paketversion, beim Start
+        // über `electron dist/gui/main.js` (npm run gui, Smoke-Test) dagegen die Electron-Version —
+        // dort liegt neben dem Hauptskript keine package.json (gemessen: 44.0.0 statt 0.0.6).
+        title: `hmgr ${paketVersion()}`,
         // Im Smoke-Test bleibt das Fenster unsichtbar: der Renderer lädt trotzdem vollständig, der
         // DOM-Auszug kommt per executeJavaScript. So klaut ein automatisierter Lauf niemandem den
         // Eingabefokus und öffnet kein sichtbares Fenster.
@@ -400,6 +497,9 @@ function fensterOeffnen() {
     hauptfenster.on('closed', () => {
         hauptfenster = null;
     });
+    // Der <title> der index.html setzt den Fenstertitel beim Laden sonst zurück und überschriebe die
+    // Option oben (E72). Der DOM-Titel bleibt dabei, wie er ist, nur das Fenster folgt ihm nicht mehr.
+    hauptfenster.on('page-title-updated', (ereignis) => ereignis.preventDefault());
     // Renderer-Konsole im Main-Log, für Fehlersuche und den Smoke-Test.
     hauptfenster.webContents.on('console-message', (event) => {
         console.log(`[renderer] ${event.message}`);
@@ -417,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.
@@ -477,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
@@ -496,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;
@@ -507,6 +683,60 @@ function fensterOeffnen() {
               // Katalog (E40 R3, R5): Beschreibung aus dem Fixture muss in der Skill-Zeile stehen.
               document.querySelector('[data-ansicht="katalog"]')?.click();
               var katalogBeschreibung = document.querySelector('#katalog .zeile .beschreibung')?.textContent ?? null;
+              // 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
@@ -524,12 +754,45 @@ function fensterOeffnen() {
               var dskKnopf = Array.from(document.querySelectorAll('button'))
                 .find((b) => b.textContent === 'Skills hinzufügen');
               var dskMarken = null;
+              // Bundle-Sektion im selben Dialog (E69, F68): sie steht dort, wo die Entscheidung
+              // fällt, was ins Ziel kommt, und zeigt je Bundle Beschreibung und Herkunft.
+              var dskBundleBoxSichtbar = false;
+              var dskBundleText = null;
               if (dskKnopf) {
                 dskKnopf.click();
                 dskMarken = document.querySelector('#dsk-liste .wahlzeile .marken')?.textContent
                   ?.replace(/\\s+/g, ' ').trim() ?? null;
+                dskBundleBoxSichtbar = document.getElementById('dsk-bundlebox')?.hidden === false;
+                dskBundleText = document.querySelector('#dsk-bundles .wahlzeile')?.textContent
+                  ?.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
+                ?.replace(/\\s+/g, ' ').trim() ?? null;
+              var bundleGruppeZeilen = Array.from(document.querySelectorAll('#zielliste .bundlegruppe .linkliste .name'))
+                .map((n) => n.textContent.trim()).join(',');
+              // Entfernen an der Einzelzeile innerhalb der Gruppe sagt, dass das Bundle zerbricht.
+              var bundleZerbrichtText = null;
+              try {
+                document.querySelector('#zielliste .bundlegruppe .linkliste .knopf')?.click();
+                bundleZerbrichtText = document.getElementById('dx-text')?.textContent ?? null;
+                document.querySelector('#d-entfernen button[value="nein"]')?.click();
+              } catch (fehler) {
+                bundleZerbrichtText = String(fehler);
+              }
               // MCP-Ansicht (E61-Folgerunde, F46: abgespeckt zum reinen Katalog): Navigationsreihenfolge
               // Ziele, MCP, Plugins, Skills, Karten mit Name/Beschreibung/Homepage-Link, F39-Warnzeile,
               // Einhängen-Dialog öffnen/abbrechen ohne IPC-Schreibaktion. Orte-Liste und Fremdkasten
@@ -640,12 +903,33 @@ function fensterOeffnen() {
                 ?.replace(/\\s+/g, ' ').trim() ?? null;
               var kundeXMcpZeilenKnopfZahl = kundeXKarte?.querySelectorAll('.mcpkartezeilen button').length ?? 0;
               var kundeXMcpKnopfVorhanden = mcpHinzuKnopfAn(kundeXKarte) !== undefined;
+              // Kartenkopf-Zahl (E71): der Kopf zählt Skills, gebündelt wie der Körper zeilt. An der
+              // Verzeichnis-Karte kunde-x hängen dieselben zwei Skills an zwei Harnesses, eine Summe
+              // über die Abschnitte ergäbe hier 4.
+              var kopfZahlVon = function (karte) {
+                return karte?.querySelector('.zielkopf .zahl')?.textContent?.trim() ?? null;
+              };
+              var kundeXKopfZahl = kopfZahlVon(kundeXKarte);
+              var hermesKopfZahl = kopfZahlVon(hermesKarte);
               var agentsKarte = karteMitKopftext('Agents · Home');
               // Ohne diese Zusicherung wären die beiden Abwesenheits-Prüfungen darunter leer erfüllt,
               // sobald die Karte selbst aus der Liste fiele: „kein Abschnitt" hieße dann nur „keine Karte".
               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;
@@ -673,17 +957,46 @@ 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,
                 katalogDetails,
                 katalogMarkenWarnend,
                 dskMarken,
+                dskBundleBoxSichtbar,
+                dskBundleText,
+                dzZieleText,
+                bundleGruppeText,
+                bundleGruppeZeilen,
+                bundleZerbrichtText,
                 interGeladen: document.fonts.check('400 16px Inter'),
                 monoGeladen: document.fonts.check('500 16px "JetBrains Mono"'),
                 quelleneuVorhanden,
@@ -733,6 +1046,14 @@ function fensterOeffnen() {
                 kundeXMcpText,
                 kundeXMcpZeilenKnopfZahl,
                 kundeXMcpKnopfVorhanden,
+                kundeXKopfZahl,
+                hermesKopfZahl,
+                hermesWarnzahl,
+                hermesWarnlabel,
+                kundeXWarnzahl,
+                kundeXWarnlabel,
+                agentsWarnungVorhanden,
+                quellenLeerDisplay,
                 agentsKarteVorhanden,
                 agentsMcpAbschnittVorhanden,
                 agentsMcpKnopfVorhanden,
@@ -740,22 +1061,39 @@ 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}`))
+                    // E72: der Fenstertitel steht nicht im DOM (dort steht weiter der <title> der
+                    // index.html), er lässt sich nur hier im Main-Prozess ablesen.
+                    .then(() => console.log(`[smoke] Fenster: ${JSON.stringify({ fenstertitel: fenster.getTitle() })}`))
                     .finally(() => app.quit());
             }, 3000);
         });
     }
     // 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.
@@ -777,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.
@@ -811,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();