hmgr 0.0.5 → 0.0.7

package/dist/gui/main.js

@@ -2,19 +2,42 @@
 // registriert IPC-Handler für den Renderer und implementiert den Rückfrage-Port als Dialog im
 // 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, shell } from 'electron';
+import { app, BrowserWindow, dialog, ipcMain, Menu, shell } from 'electron';
 import path from 'node:path';
-import os from 'node:os';
 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";
 import { entscheideOeffnen } from "./oeffnen.js";
+import { mcpUebernahmeSerialisieren, mcpUebersichtSerialisieren, mcpWirkungSerialisieren } from "./mcp-ansicht.js";
+import { beobachten } from "./beobachter.js";
+import { loginPathUebernehmen } from "./login-pfad.js";
 const hierVerzeichnis = path.dirname(fileURLToPath(import.meta.url));
 const smoketest = process.env.HMGR_GUI_SMOKETEST === '1';
+/**
+ * Nur eine hmgr-Instanz je Nutzer (E67). Grund: zwei laufende Fenster schrieben nacheinander auf
+ * dieselbe `state.json` und überschrieben sich gegenseitig — der Zustand ist einer, nicht einer je
+ * Fenster. Die zweite Instanz bekommt den Lock nicht und beendet sich; die erste holt in
+ * `second-instance` ihr Fenster nach vorn, damit der zweite Start nicht wirkungslos aussieht.
+ * Gilt auf allen Plattformen: unter macOS ist der Doppelstart selten (das Dock startet nicht neu),
+ * unter Windows ist ein zweiter Klick im Startmenü der Normalfall.
+ *
+ * Der Lock wird ganz früh geholt, noch vor `bauen()` und der PATH-Ermittlung: eine Instanz, die
+ * ohnehin gleich wieder geht, soll nichts mehr anfassen und keine Shell mehr starten.
+ *
+ * Im Smoke-Test ist er aus. Er hängt am Electron-userData-Verzeichnis, und das leitet macOS nicht
+ * über das gefälschte HOME um (gemessen, siehe E67) — eine offene hmgr-GUI auf dem Rechner würde
+ * den Smoke-Lauf sonst stumm abwürgen. Dieselbe Zurückhaltung wie bei Watcher und
+ * Auto-Aktualisieren: was einen automatisierten Lauf von außen stören kann, bleibt im Smoke aus.
+ */
+const einzelinstanz = smoketest || app.requestSingleInstanceLock();
+if (!einzelinstanz)
+    app.quit();
 const umgebung = umgebungLesen();
 /** Cache der Quellen-Icons (E60), unterhalb von HMGR_HOME wie der Zustand: Tests/Smoke fassen so
     nie ein echtes Verzeichnis an. */
@@ -23,10 +46,16 @@ const iconCacheVerzeichnis = path.join(umgebung.hmgrHome, 'icon-cache');
 const SECHS_STUNDEN_MS = 6 * 60 * 60 * 1000;
 /**
  * Fake der claude-CLI für den Smoke-Test (E40 R4), nach dem Muster von `fakeClaude` in
- * tests/helfer.ts: nie `code: 0`, also ohne Plugin-Fähigkeit, wie ohne installierte CLI. So fasst
- * ein automatisierter Lauf formal nie die echte claude-CLI an, auch wenn sie auf dem PATH liegt.
+ * tests/helfer.ts. Kein Kindprozess, keine echte CLI: ein automatisierter Lauf fasst die echte
+ * claude-CLI formal nie an, auch wenn sie auf dem PATH liegt.
+ *
+ * `--version` läuft durch, damit Claude Code im Smoke-Test seine Fähigkeiten bekommt (E61: die
+ * MCP-Fähigkeit hängt an der vorhandenen CLI). Sonst blieben die Claude-Code-Zeilen der MCP-Ansicht
+ * ungetestet. Jeder andere Aufruf scheitert mit Code 1: die lesenden Pfade tragen das (Plugin-Liste
+ * leer, `eingehaengte` liest ohnehin nur ~/.claude.json), und die schreibenden bleiben so
+ * verschlossen — der Smoke-Test hängt nichts ein und aus, er öffnet die Dialoge nur.
  */
-const smoketestClaudeAusfuehrer = async () => ({ stdout: '', code: 1 });
+const smoketestClaudeAusfuehrer = async (args) => args[0] === '--version' ? { stdout: 'claude 0.0.0-smoke\n', code: 0 } : { stdout: '', code: 1 };
 let hauptfenster = null;
 /**
  * Rückfrage-Port als Dialog im Renderer (E28, E34): der Main-Prozess schickt die Frage per
@@ -63,12 +92,34 @@ class GuiRueckfrage {
         return typeof antwort === 'number' ? antwort : undefined;
     }
 }
+/**
+ * PATH aus der Login-Shell (F47=O2, E63): aus dem Finder gestartet bekommt die App nur den
+ * macOS-Minimal-PATH, ohne z. B. ~/.local/bin mit der claude-CLI. Die Ermittlung läuft ab hier
+ * parallel zum Electron-Start; gewartet wird zentral in `auffangen`, und damit vor jedem
+ * Adapter-Aufruf, denn jeder IPC-Handler geht durch `auffangen` und Spawns gibt es nur dort
+ * (claude-code.ts, git.ts — Watcher, Fokus-Reload und Auto-Aktualisieren stoßen den Renderer an,
+ * der wieder über IPC hereinkommt).
+ *
+ * Bewusst kein Top-Level-`await`: im ESM-Main-Entry läuft vor `ready` nur, was die Imports als
+ * Nebeneffekt tun; ein Await dort verschiebt die Registrierung aller App-Handler und verzögert
+ * das Fenster um die Laufzeit der Shell (~2 s). So erscheint das Fenster sofort, und höchstens
+ * der erste Datenabruf wartet. Im Smoke-Test unterbleibt die Ermittlung ganz (nie eine echte
+ * Shell, Muster: Watcher/Auto-Aktualisieren sind im Smoke auch aus). Der `catch` ist die letzte
+ * Leine: dieser Aufruf darf die App unter keinen Umständen stören.
+ *
+ * Unter Windows steigt `loginPathUebernehmen` selbst sofort aus (E67): dort gibt es keine
+ * Login-Shell im POSIX-Sinn und keine PATH-Lücke zu füllen.
+ */
+const pathBereit = smoketest || !einzelinstanz
+    ? Promise.resolve()
+    : loginPathUebernehmen().catch(() => undefined);
 const rueckfrage = new GuiRueckfrage();
-const { anwendungsfaelle } = bauen(umgebung, {
+const { anwendungsfaelle, ports } = bauen(umgebung, {
     rueckfrage,
     ...(smoketest ? { claudeAusfuehrer: smoketestClaudeAusfuehrer } : {}),
 });
 async function auffangen(fn) {
+    await pathBereit; // erst der Login-PATH (F47=O2), dann der Adapter — sonst findet er die CLI nicht
     try {
         return { ok: true, daten: await fn() };
     }
@@ -86,6 +137,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 }),
@@ -97,8 +156,13 @@ function zielAusIpc(harness, ort) {
 }
 function registriereIpc() {
     ipcMain.handle('hmgr:version', async () => auffangen(async () => app.getVersion()));
-    // Für pfadKurz im Renderer (Anzeige-Kürzung auf ~): nur lesend, nie in einen anderen Aufruf zurückgespeist.
-    ipcMain.handle('hmgr:home', async () => auffangen(async () => os.homedir()));
+    // Für pfadKurz im Renderer (Anzeige-Kürzung auf ~): nur lesend, nie in einen anderen Aufruf
+    // zurückgespeist. Dasselbe Home wie der Kern (`umgebungLesen`: `HOME` vor `os.homedir()`, E68) —
+    // sonst kürzt die Anzeige dort nicht, wo HOME abweichend gesetzt ist (MSYS/Git-Bash).
+    ipcMain.handle('hmgr:home', async () => auffangen(async () => umgebung.home));
+    // Ebenfalls nur für die Anzeige (E68): der Renderer leitet daraus den Pfadtrenner ab, mit dem er
+    // eigene Anzeigepfade zusammensetzt („~/.claude.json" bzw. „~\.claude.json").
+    ipcMain.handle('hmgr:plattform', async () => auffangen(async () => process.platform));
     ipcMain.handle('hmgr:istZustand', async () => auffangen(async () => (await anwendungsfaelle.istZustand()).map(zielZustandSerialisieren)));
     ipcMain.handle('hmgr:marketplaces', async () => auffangen(async () => (await anwendungsfaelle.marketplaces()).map((m) => ({
         quelleText: quelleAlsText(m.quelle),
@@ -126,6 +190,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),
@@ -134,6 +199,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,
@@ -230,7 +334,7 @@ function registriereIpc() {
     // Quelle öffnen (E60): die Protokoll-Weiche steht in oeffnen.ts (rein, testbar), hier nur die
     // Wirkung. `shell.openExternal` bekommt ausschließlich http(s)-URLs, `shell.openPath` nur einen
     // Ordner, den es wirklich gibt — nichts anderes wird zugelassen. Alles, was es gibt, aber kein
-    // Ordner ist, wird im Finder nur gezeigt, nicht geöffnet: `openPath` startet sonst eine Datei
+    // Ordner ist, wird im Dateimanager nur gezeigt, nicht geöffnet: `openPath` startet sonst eine Datei
     // mit ihrem Standardprogramm, und ein Pfad aus dem Renderer soll nichts starten können.
     ipcMain.handle('hmgr:quelleOeffnen', async (_event, quelleText) => auffangen(async () => {
         const entscheidung = entscheideOeffnen(quelleAusText(quelleText));
@@ -247,7 +351,83 @@ function registriereIpc() {
         }
         return entscheidung;
     }));
+    // MCP-Ansicht (E61-Folgerunde): Whitelisting und der F39-Vermerk je Karte stehen in mcp-ansicht.ts
+    // (rein, ohne Electron, wie oeffnen.ts und icons.ts), damit sie testbar sind. Der Main-Prozess
+    // ruft nur noch auf und liefert die eigene Prozess-Umgebung für die F39-Prüfung.
+    ipcMain.handle('hmgr:mcpUebersicht', async () => auffangen(async () => mcpUebersichtSerialisieren(await anwendungsfaelle.mcpUebersicht(), process.env)));
+    // Plätze für den Einhängen-Dialog (F42): die Fähigkeit hängt am Adapter, nicht am Namen (E16),
+    // deshalb kommt die Liste unverändert aus dem Kern statt aus einer Harness-Fallunterscheidung hier.
+    ipcMain.handle('hmgr:mcpPlaetze', async () => auffangen(async () => anwendungsfaelle.mcpPlaetze()));
+    ipcMain.handle('hmgr:mcpEinhaengen', async (_event, args) => auffangen(async () => mcpWirkungSerialisieren(await anwendungsfaelle.mcpEinhaengen({ name: args.name, ziel: zielAusIpc(args.harness, args.ort) }))));
+    ipcMain.handle('hmgr:mcpAushaengen', async (_event, args) => auffangen(async () => mcpWirkungSerialisieren(await anwendungsfaelle.mcpAushaengen({ name: args.name, ziel: zielAusIpc(args.harness, args.ort) }))));
+    // Übernehmen aus der geteilten .mcp.json (E64): die Bestätigung holt der Renderer ein, hier läuft
+    // nur die Ausführung. Der Name muss nicht im Katalog stehen.
+    ipcMain.handle('hmgr:mcpUebernehmen', async (_event, args) => auffangen(async () => mcpUebernahmeSerialisieren(await anwendungsfaelle.mcpUebernehmen({ name: args.name, ziel: zielAusIpc(args.harness, args.ort) }))));
+}
+/** Mindestabstand zwischen zwei Fokus-Reloads (E62): schnelles Fenster-Wechseln löst keine Lawine
+    von Anzeige-Neuladungen aus. Getrennt vom Entprellen im Datei-Watcher (das sammelt Events vor dem
+    ersten Aufruf), hier wird zusätzlich zwischen aufeinanderfolgenden Aufrufen gedrosselt (trailing:
+    ein Aufruf innerhalb der Sperrzeit wird nicht verworfen, sondern ans Ende der Sperrzeit verschoben). */
+const FOKUS_RELOAD_MIN_ABSTAND_MS = 3000;
+/** Sammelzeit des Datei-Watchers (E62): mehrere Events in kurzer Folge lösen einen Reload aus. */
+const BEOBACHTER_ENTPRELLEN_MS = 400;
+/**
+ * Pfade, die die GUI kennt und darum beobachtet (E62): hmgr-Zustand samt MCP-Katalog, die
+ * Harness-MCP-Konfigurationen (`~/.claude.json`, Hermes' `config.yaml`) und die `.env`-Dateien, die
+ * die F39-Prüfung beim MCP-Einhängen liest — bei Hermes liegt die `.env` je Ort neben der
+ * `config.yaml` (so liest sie der Adapter in `mcp.envDatei`), darum auch je Profil. Die Profile
+ * werden einmal beim Start am Harness selbst erfragt (`profile()`, ein Verzeichnis-Blick, kein
+ * ganzer Erhebungslauf); ein zur Laufzeit neu angelegtes Profil beobachtet der Watcher nicht
+ * dynamisch, das deckt der Fokus-Reload ab (E62).
+ *
+ * Nicht dabei: die geteilten `.mcp.json` der Arbeitsverzeichnisse, die die MCP-Übersicht seit dem
+ * E61-Nachtrag mitliest. Ihre Liste ist zur Laufzeit veränderlich, wie die der Hermes-Profile, und
+ * damit gilt für sie dasselbe: der Fokus-Reload deckt sie ab.
+ */
+async function beobachtetePfade() {
+    const hermesHome = path.join(umgebung.home, '.hermes');
+    const pfade = [
+        path.join(umgebung.hmgrHome, 'state.json'),
+        path.join(umgebung.hmgrHome, 'mcp.yaml'),
+        path.join(umgebung.home, '.claude.json'),
+        path.join(hermesHome, 'config.yaml'),
+        path.join(hermesHome, '.env'),
+    ];
+    const hermes = ports.harnesses.find((h) => h.name === 'hermes');
+    if (hermes !== undefined && kannProfile(hermes))
+        for (const name of await hermes.profile().catch(() => [])) {
+            const profilHome = path.join(hermesHome, 'profiles', name);
+            pfade.push(path.join(profilHome, 'config.yaml'), path.join(profilHome, '.env'));
+        }
+    return pfade;
 }
+/**
+ * Stößt beim Renderer ein stilles Neuladen der Anzeige an (E62), nie einen Aktualisieren-Lauf mit
+ * Netzzugriff. Gedrosselt (trailing throttle): unmittelbar, wenn seit dem letzten Anstoß genug Zeit
+ * verging, sonst genau ein nachgeholter Anstoß am Ende der Sperrzeit.
+ */
+function neuLadenAnstossenFabrik(minAbstandMs) {
+    let letzter = 0;
+    let timer;
+    return function anstossen() {
+        const jetzt = Date.now();
+        const seitLetztem = jetzt - letzter;
+        if (seitLetztem >= minAbstandMs) {
+            letzter = jetzt;
+            hauptfenster?.webContents.send('hmgr:neuLadenAnstossen');
+            return;
+        }
+        if (timer !== undefined)
+            return; // schon ein Anstoß fürs Ende der Sperrzeit vorgemerkt
+        timer = setTimeout(() => {
+            timer = undefined;
+            letzter = Date.now();
+            hauptfenster?.webContents.send('hmgr:neuLadenAnstossen');
+        }, minAbstandMs - seitLetztem);
+    };
+}
+const neuLadenAnstossen = neuLadenAnstossenFabrik(FOKUS_RELOAD_MIN_ABSTAND_MS);
+let beobachter;
 function fensterOeffnen() {
     hauptfenster = new BrowserWindow({
         width: 1280,
@@ -255,6 +435,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.
@@ -269,6 +454,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}`);
@@ -368,11 +556,17 @@ function fensterOeffnen() {
               // 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;
+              // E55-Marken auch in der Ziel-Tabelle, unter der Beschreibung (2026-09-05).
+              var zielMarken = document.querySelector('#zielliste .linkliste .wasfeld .marken')?.textContent
+                ?.replace(/\\s+/g, ' ').trim() ?? null;
               var zielManuellVorhanden = (document.getElementById('zielliste')?.textContent ?? '').includes('manuell');
               var zahnradVorhanden = (document.querySelector('#einstellungen svg')?.innerHTML ?? '').includes('6.47 3.56');
               // 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;
               // 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
@@ -390,12 +584,173 @@ 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();
               }
+              // 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
+              // gehören seit F46 nicht mehr in diese Ansicht (die Prüfung darauf ist unten invertiert),
+              // sie leben nur noch am MCP-Abschnitt der Ziel-Karten (weiter unten unverändert geprüft).
+              var navReihenfolge = Array.from(document.querySelectorAll('.nav [data-ansicht]'))
+                .map((b) => b.dataset.ansicht).join(',');
+              document.querySelector('[data-ansicht="mcp"]')?.click();
+              var mcpKartenText = document.getElementById('mcpliste')?.textContent
+                ?.replace(/\\s+/g, ' ').trim() ?? null;
+              var mcpHeimLinkVorhanden = document.querySelector('#mcpliste .mcpkopf .qlink') !== null;
+              var mcpWarnzeileVorhanden = document.querySelector('#mcpliste .mcp .ruhezeile') !== null;
+              // F46: die Orte-Liste je Karte und der Fremdkasten der Ansicht sind ganz weg, nicht nur
+              // leer — beide Selektoren dürfen im DOM überhaupt nicht mehr auftauchen.
+              var mcpOrteVorhanden = document.querySelector('#mcpliste .mcporte') !== null;
+              var mcpFremdkastenVorhanden = document.getElementById('mcpfremd') !== null;
+              var mcpFehler = null;
+              var dMcpOffenNachOeffnen = false;
+              var dMcpOffenNachAbbrechen = true;
+              // Die Wahlzeilen des Einhängen-Dialogs (F42): sie kommen aus der Adapter-Fähigkeit,
+              // hier steht, welche Orte zur Wahl stehen und wohin der Eintrag jeweils ginge. Zwei
+              // Karten, weil die Zeilen verschieden aussehen: „mail" hängt an beiden Home-Orten
+              // schon (gesperrte Zeile), „teamwork" nirgends (die Notizen je Ort).
+              var mcpWahlText = null;
+              var mcpWahlTextFrei = null;
+              try {
+                var mcpEinKnoepfe = Array.from(document.querySelectorAll('#mcpliste .mcpkopf button'))
+                  .filter((b) => (b.textContent || '').indexOf('Einhängen') === 0);
+                var mcpWahlOeffnen = async (knopf) => {
+                  knopf?.click();
+                  // window.hmgr.mcpPlaetze() ist asynchron: kurz nachfassen, bis die Wahlzeilen stehen.
+                  await new Promise((r) => setTimeout(r, 200));
+                  return document.getElementById('dm-orte')?.textContent?.replace(/\\s+/g, ' ').trim() ?? null;
+                };
+                mcpWahlText = await mcpWahlOeffnen(mcpEinKnoepfe[0]);
+                dMcpOffenNachOeffnen = document.getElementById('d-mcp')?.open === true;
+                document.querySelector('#d-mcp button[value="abbruch"]')?.click();
+                dMcpOffenNachAbbrechen = document.getElementById('d-mcp')?.open === true;
+                mcpWahlTextFrei = await mcpWahlOeffnen(mcpEinKnoepfe[1]);
+                document.querySelector('#d-mcp button[value="abbruch"]')?.click();
+              } catch (fehler) {
+                mcpFehler = String(fehler);
+              }
+              // Aushängen-Rückfrage (F46: nur noch über den Entfernen-Knopf am MCP-Abschnitt einer
+              // Ziel-Karte auslösbar, die MCP-Ansicht selbst hat dafür keinen Knopf mehr).
+              var mcpAusFehler = null;
+              var dMcpAusOffenNachOeffnen = false;
+              var dMcpAusOffenNachAbbrechen = true;
+              // Seit E64 stehen im MCP-Abschnitt zwei Knopfarten nebeneinander (Entfernen und
+              // Übernehmen), deshalb wird hier nicht mehr der erste Knopf genommen, sondern der
+              // Entfernen-Knopf an seinem aria-label erkannt.
+              var mcpZeilenKnoepfe = Array.from(document.querySelectorAll('#zielliste .mcpkartezeilen button'));
+              try {
+                var mcpAusKnopf = mcpZeilenKnoepfe.find(function (b) {
+                  return (b.getAttribute('aria-label') || '').indexOf('aushängen') > -1;
+                });
+                mcpAusKnopf?.click();
+                dMcpAusOffenNachOeffnen = document.getElementById('d-mcpaus')?.open === true;
+                document.querySelector('#d-mcpaus button[value="nein"]')?.click();
+                dMcpAusOffenNachAbbrechen = document.getElementById('d-mcpaus')?.open === true;
+              } catch (fehler) {
+                mcpAusFehler = String(fehler);
+              }
+              // Übernehmen aus der geteilten .mcp.json (E64): Knopf an einer geteilten Zeile,
+              // Rückfrage öffnen und über „Nein" wieder schließen — ohne IPC-Schreibaktion, wie bei
+              // den anderen MCP-Dialogen. Der Text der Rückfrage läuft mit, er ist die Warnung an
+              // den Nutzer und darf nicht stillschweigend verschwinden.
+              var mcpUebFehler = null;
+              var dMcpUebOffenNachOeffnen = false;
+              var dMcpUebOffenNachAbbrechen = true;
+              var mcpUebText = null;
+              try {
+                var mcpUebKnopf = mcpZeilenKnoepfe.find(function (b) {
+                  return (b.textContent || '').indexOf('Übernehmen') === 0;
+                });
+                mcpUebKnopf?.click();
+                dMcpUebOffenNachOeffnen = document.getElementById('d-mcpueb')?.open === true;
+                mcpUebText = document.getElementById('dmu-text')?.textContent?.replace(/\\s+/g, ' ').trim() ?? null;
+                document.querySelector('#d-mcpueb button[value="nein"]')?.click();
+                dMcpUebOffenNachAbbrechen = document.getElementById('d-mcpueb')?.open === true;
+              } catch (fehler) {
+                mcpUebFehler = String(fehler);
+              }
+              // MCP an der Ziel-Karte (E61-GUI-Nachtrag), Gegenrichtung zur MCP-Ansicht: Abschnitt und
+              // Knopf an der Hermes-Home-Karte (Katalog-Zeile mit Entfernen, Fremd-Zeile ohne Knopf)
+              // und an der kunde-x-Verzeichnis-Karte (zwei Zeilen aus der geteilten .mcp.json, seit
+              // E64 beide mit Übernehmen-Knopf), dazu die Knopf-Sichtbarkeit: an der agents-Karte
+              // darf weder Abschnitt noch Knopf stehen, agents implementiert die MCP-Fähigkeit
+              // nicht (E16).
+              var zielKarten = Array.from(document.querySelectorAll('#zielliste .ziel'));
+              var karteMitKopftext = function (t) {
+                return zielKarten.find(function (k) {
+                  return (k.querySelector('.zielkopf')?.textContent || '').indexOf(t) > -1;
+                });
+              };
+              var mcpHinzuKnopfAn = function (karte) {
+                return karte
+                  ? Array.from(karte.querySelectorAll('button')).find((b) => (b.textContent || '').indexOf('MCP hinzufügen') === 0)
+                  : undefined;
+              };
+              var hermesKarte = karteMitKopftext('Hermes · Home');
+              var hermesMcpText = hermesKarte?.querySelector('.mcpkarteabschnitt')?.textContent
+                ?.replace(/\\s+/g, ' ').trim() ?? null;
+              var hermesMcpZeilenKnopfZahl = hermesKarte?.querySelectorAll('.mcpkartezeilen button').length ?? 0;
+              var hermesMcpKnopfVorhanden = mcpHinzuKnopfAn(hermesKarte) !== undefined;
+              var kundeXKarte = karteMitKopftext('kunde-x');
+              var kundeXMcpText = kundeXKarte?.querySelector('.mcpkarteabschnitt')?.textContent
+                ?.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;
+              // 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;
+              var dMcpHinzuOffenNachOeffnen = false;
+              var dMcpHinzuOffenNachAbbrechen = true;
+              var dmhListeText = null;
+              try {
+                mcpHinzuKnopfAn(hermesKarte)?.click();
+                dMcpHinzuOffenNachOeffnen = document.getElementById('d-mcp-hinzufuegen')?.open === true;
+                dmhListeText = document.getElementById('dmh-liste')?.textContent?.replace(/\\s+/g, ' ').trim() ?? null;
+                document.querySelector('#d-mcp-hinzufuegen button[value="abbruch"]')?.click();
+                dMcpHinzuOffenNachAbbrechen = document.getElementById('d-mcp-hinzufuegen')?.open === true;
+              } catch (fehler) {
+                dmhFehler = String(fehler);
+              }
               // Schriften aus fonts/ (Zusatzpunkt 6): erzwingt das Laden und belegt es danach.
               await Promise.all([
                 document.fonts.load('400 16px Inter'),
@@ -409,15 +764,22 @@ function fensterOeffnen() {
                 einstellungenOffen,
                 harnessSchalter,
                 zielBeschreibung,
+                zielMarken,
                 zielManuellVorhanden,
                 zahnradVorhanden,
                 katalogBeschreibung,
+                katalogHerkunft,
                 katalogMarken,
                 katalogDetailsZu,
                 katalogAufgeklappt,
                 katalogDetails,
                 katalogMarkenWarnend,
                 dskMarken,
+                dskBundleBoxSichtbar,
+                dskBundleText,
+                bundleGruppeText,
+                bundleGruppeZeilen,
+                bundleZerbrichtText,
                 interGeladen: document.fonts.check('400 16px Inter'),
                 monoGeladen: document.fonts.check('500 16px "JetBrains Mono"'),
                 quelleneuVorhanden,
@@ -443,9 +805,45 @@ function fensterOeffnen() {
                 dSkillordnerOffenNachOeffnen,
                 dSkillordnerOffenNachAbbrechen,
                 skillOrdnerFehler,
+                navReihenfolge,
+                mcpKartenText,
+                mcpHeimLinkVorhanden,
+                mcpWarnzeileVorhanden,
+                mcpOrteVorhanden,
+                mcpFremdkastenVorhanden,
+                dMcpOffenNachOeffnen,
+                dMcpOffenNachAbbrechen,
+                mcpWahlText,
+                mcpWahlTextFrei,
+                mcpFehler,
+                dMcpAusOffenNachOeffnen,
+                dMcpAusOffenNachAbbrechen,
+                mcpAusFehler,
+                dMcpUebOffenNachOeffnen,
+                dMcpUebOffenNachAbbrechen,
+                mcpUebText,
+                mcpUebFehler,
+                hermesMcpText,
+                hermesMcpZeilenKnopfZahl,
+                hermesMcpKnopfVorhanden,
+                kundeXMcpText,
+                kundeXMcpZeilenKnopfZahl,
+                kundeXMcpKnopfVorhanden,
+                kundeXKopfZahl,
+                hermesKopfZahl,
+                agentsKarteVorhanden,
+                agentsMcpAbschnittVorhanden,
+                agentsMcpKnopfVorhanden,
+                dMcpHinzuOffenNachOeffnen,
+                dMcpHinzuOffenNachAbbrechen,
+                dmhListeText,
+                dmhFehler,
               });
             })()`)
                     .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);
         });
@@ -461,20 +859,65 @@ function fensterOeffnen() {
         const intervall = setInterval(() => fenster.webContents.send('hmgr:aktualisierenAnstossen'), SECHS_STUNDEN_MS);
         fenster.on('closed', () => clearInterval(intervall));
     }
+    // Die GUI erfährt von Änderungen außerhalb ihrer selbst (E62): Fokus-Reload und Datei-Watcher.
+    // Beide stoßen nur ein stilles Neuladen der Anzeige an, nie einen Aktualisieren-Lauf mit
+    // Netzzugriff. Im Smoke-Test keins von beiden, dieselbe Zurückhaltung wie beim automatischen
+    // Aktualisieren (E44): ein Event dürfte sonst in den DOM-Auszug pfuschen.
+    if (!smoketest) {
+        const fenster = hauptfenster;
+        fenster.on('focus', () => neuLadenAnstossen());
+        void beobachtetePfade().then((pfade) => {
+            if (fenster.isDestroyed())
+                return; // Fenster schon zu, während die Pfade ermittelt wurden
+            beobachter = beobachten(pfade, () => neuLadenAnstossen(), { entprellenMs: BEOBACHTER_ENTPRELLEN_MS });
+        });
+        fenster.on('closed', () => {
+            beobachter?.close();
+            beobachter = undefined;
+        });
+    }
     void hauptfenster.loadFile(path.join(hierVerzeichnis, 'renderer', 'index.html'));
 }
+/**
+ * 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.
+ */
+function fensterNachVornHolen() {
+    if (hauptfenster === null || hauptfenster.isDestroyed())
+        return;
+    if (hauptfenster.isMinimized())
+        hauptfenster.restore();
+    hauptfenster.show();
+    hauptfenster.focus();
+}
 registriereIpc();
-app.whenReady().then(() => {
-    // Im Smoke-Test kein Dock-Icon und kein Fokuswechsel: das Fenster bleibt unsichtbar (show:false
-    // oben), macOS würde aber ohne diese Zeile trotzdem ein Dock-Icon zeigen und aktivieren.
-    if (smoketest && process.platform === 'darwin')
-        app.dock?.hide();
-    fensterOeffnen();
-    app.on('activate', () => {
-        if (BrowserWindow.getAllWindows().length === 0)
-            fensterOeffnen();
+if (einzelinstanz) {
+    app.on('second-instance', () => fensterNachVornHolen());
+    app.whenReady().then(() => {
+        // Im Smoke-Test kein Dock-Icon und kein Fokuswechsel: das Fenster bleibt unsichtbar (show:false
+        // oben), macOS würde aber ohne diese Zeile trotzdem ein Dock-Icon zeigen und aktivieren.
+        if (smoketest && process.platform === 'darwin')
+            app.dock?.hide();
+        // Windows-Fensterkonventionen (E67), beide nur dort:
+        // — Die Taskleiste gruppiert Fenster und Verknüpfungen über die AppUserModelID. Ohne sie steht
+        //   der Prozess unter einer von Windows geratenen ID, und das angeheftete Startmenü-Symbol
+        //   gehört dann nicht zum laufenden Fenster. Dieselbe ID wie die `appId` im build-Block, denn
+        //   die schreibt der NSIS-Installer in die Verknüpfung.
+        // — Electron blendet unter Windows sonst sein Standardmenü ein (Datei/Bearbeiten/Ansicht/…),
+        //   eine Menüleiste, die hmgr nicht bedient und die nur Platz über der Ansicht kostet. macOS
+        //   bleibt unangetastet: dort ist die Menüleiste des Systems Pflicht (Beenden, Kopieren,
+        //   Einfügen hängen daran).
+        if (process.platform === 'win32') {
+            app.setAppUserModelId('de.timkaufmann.hmgr');
+            Menu.setApplicationMenu(null);
+        }
+        fensterOeffnen();
+        app.on('activate', () => {
+            if (BrowserWindow.getAllWindows().length === 0)
+                fensterOeffnen();
+        });
     });
-});
+}
 app.on('window-all-closed', () => {
     if (process.platform !== 'darwin')
         app.quit();