hmgr 0.0.4 → 0.0.6

package/dist/gui/main.js

@@ -0,0 +1,823 @@
+// hmgr-GUI, Electron-Main (E40). Baut dieselben Anwendungsfälle wie die CLI (src/cli/main.ts),
+// 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, Menu, shell } from 'electron';
+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 { 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. */
+const iconCacheVerzeichnis = path.join(umgebung.hmgrHome, 'icon-cache');
+/** Intervall des selbsttätigen Aktualisierens (E44): fest, keine Einstellung. */
+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. 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 (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
+ * `webContents.send`, der Renderer zeigt einen <dialog> im Stil des Entwurfs und schickt die
+ * Antwort über einen Kanal mit Korrelations-ID zurück. Ohne offenes Fenster kann niemand antworten,
+ * dort gilt wie am Terminal ohne TTY: Nein bzw. keine Antwort (E34).
+ */
+class GuiRueckfrage {
+    ausstehend = new Map();
+    constructor() {
+        ipcMain.on('hmgr:rueckfrage:antwort', (_event, nachricht) => {
+            const aufloesen = this.ausstehend.get(nachricht.id);
+            if (aufloesen === undefined)
+                return;
+            this.ausstehend.delete(nachricht.id);
+            aufloesen(nachricht.antwort);
+        });
+    }
+    stellen(payload) {
+        if (hauptfenster === null)
+            return Promise.resolve(payload.art === 'bestaetigen' ? false : undefined);
+        const id = randomUUID();
+        return new Promise((aufloesen) => {
+            this.ausstehend.set(id, aufloesen);
+            hauptfenster?.webContents.send('hmgr:rueckfrage', { id, ...payload });
+        });
+    }
+    async bestaetigen(frage) {
+        const antwort = await this.stellen({ art: 'bestaetigen', frage });
+        return antwort === true;
+    }
+    async auswaehlen(frage, optionen) {
+        const antwort = await this.stellen({ art: 'auswaehlen', frage, optionen });
+        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, 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() };
+    }
+    catch (fehler) {
+        return { ok: false, fehler: fehler instanceof Error ? fehler.message : String(fehler) };
+    }
+}
+/** ZielZustand über IPC: Maps werden zu einfachen Objekten, der Rest ist schon JSON-tauglich. */
+function zielZustandSerialisieren(z) {
+    return {
+        ziel: z.ziel,
+        verzeichnis: z.verzeichnis,
+        eintraege: z.eintraege,
+        einschraenkungen: Object.fromEntries(z.einschraenkungen),
+        gruende: Object.fromEntries(z.gruende),
+        ignoriert: z.ignoriert,
+        uebernahme: Object.fromEntries(z.uebernahme),
+        istRegistriert: z.istRegistriert,
+        kannSkillOrdner: z.kannSkillOrdner,
+        ...(z.plugins === undefined ? {} : { plugins: z.plugins }),
+        ...(z.verwalteterSkillOrdner === undefined ? {} : { verwalteterSkillOrdner: z.verwalteterSkillOrdner }),
+    };
+}
+function zielAusIpc(harness, ort) {
+    return { 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. 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),
+        name: m.name,
+        plugins: m.plugins,
+    }))));
+    // Skill-Katalog über alle bekannten Quellen (E40 R3): über den Anwendungsfall `katalog`, nicht
+    // mehr direkt über die Ports. Eine nicht erreichbare Quelle trägt einen Fehlervermerk (E12-Muster
+    // wie istZustand/marketplaces), ihre Skills fehlen einfach in der flachen Liste.
+    ipcMain.handle('hmgr:skills', async () => auffangen(async () => {
+        const ergebnis = [];
+        for (const eintrag of await anwendungsfaelle.katalog()) {
+            if (eintrag.ref === undefined)
+                continue; // nicht erreichbar, keine Skills
+            for (const skill of eintrag.skills)
+                ergebnis.push({
+                    name: skill.name,
+                    pfad: skill.pfad,
+                    ...(skill.beschreibung === undefined ? {} : { beschreibung: skill.beschreibung }),
+                    ...(skill.nurPerBefehl === undefined ? {} : { nurPerBefehl: skill.nurPerBefehl }),
+                    ...(skill.nichtPerBefehl === undefined ? {} : { nichtPerBefehl: skill.nichtPerBefehl }),
+                    ...(skill.registriertHooks === undefined ? {} : { registriertHooks: skill.registriertHooks }),
+                    ...(skill.werkzeugeErlaubt === undefined ? {} : { werkzeugeErlaubt: skill.werkzeugeErlaubt }),
+                    ...(skill.kompatibilitaet === undefined ? {} : { kompatibilitaet: skill.kompatibilitaet }),
+                    ...(skill.modell === undefined ? {} : { modell: skill.modell }),
+                    ...(skill.eigenerKontext === undefined ? {} : { eigenerKontext: skill.eigenerKontext }),
+                    ...(skill.argumentHinweis === undefined ? {} : { argumentHinweis: skill.argumentHinweis }),
+                    quelleText: quelleAlsText(eintrag.quelle),
+                    quelleName: quelleName(eintrag.quelle),
+                    quelleSchluessel: quelleSchluessel(eintrag.quelle),
+                    ref: eintrag.ref,
+                });
+        }
+        return ergebnis;
+    }));
+    // 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,
+        text: quelleAlsText(quelle),
+        name: quelleName(quelle),
+    }))));
+    // Quelle-Verwaltung in den Einstellungen (E54, E59): Text-zu-Quelle passiert im Main-Prozess, der
+    // Renderer kennt nur Zeichenketten. Der Anzeigename kommt serverseitig mit, damit dem Renderer nie
+    // ein weggefiltertes Feld fehlt (E59: „name" ist reine Anzeige, geht nicht in quelleAusText ein).
+    ipcMain.handle('hmgr:quelleHinzufuegen', async (_event, text, name) => auffangen(async () => {
+        const ergebnis = await anwendungsfaelle.quelleHinzufuegen(quelleAusText(text), name);
+        return {
+            quelle: {
+                art: ergebnis.quelle.art,
+                text: quelleAlsText(ergebnis.quelle),
+                name: quelleName(ergebnis.quelle),
+            },
+            skills: ergebnis.skills,
+            marketplace: ergebnis.marketplace,
+            bekannt: ergebnis.bekannt,
+        };
+    }));
+    ipcMain.handle('hmgr:quelleEntfernen', async (_event, text) => auffangen(async () => anwendungsfaelle.quelleEntfernen(quelleAusText(text))));
+    ipcMain.handle('hmgr:quelleUmbenennen', async (_event, text, name) => auffangen(async () => {
+        const umbenannt = await anwendungsfaelle.quelleUmbenennen(quelleAusText(text), name);
+        return { art: umbenannt.art, text: quelleAlsText(umbenannt), name: quelleName(umbenannt) };
+    }));
+    // Aufräum-Angebot nach dem Entfernen einer Quelle (E58): Inventar vor dem eigentlichen Entfernen
+    // erheben (der Renderer ruft das, bevor er quelleEntfernen aufruft), dann bei Zustimmung abräumen.
+    // Beide Ergebnisse reichen unverändert durch: schon reine Daten, keine Maps oder Funktionen darin.
+    ipcMain.handle('hmgr:quelleAufraeumInventar', async (_event, text) => auffangen(async () => anwendungsfaelle.quelleAufraeumInventar(quelleAusText(text))));
+    ipcMain.handle('hmgr:quelleAufraeumen', async (_event, inventar) => auffangen(async () => anwendungsfaelle.quelleAufraeumen(inventar)));
+    // Die GUI arbeitet an einem Arbeitsverzeichnis wie die CLI mit --local (E57, F32): Links werden
+    // lokal gelegt und entfernt, der Zeiger bleibt unangetastet, der Kern hängt bei einer bestehenden
+    // Bindung von sich aus einen Hinweis an. Für Home und Profil ist `lokal` folgenlos (E26).
+    ipcMain.handle('hmgr:linkLegen', async (_event, args) => auffangen(async () => anwendungsfaelle.linkLegen({
+        skill: args.skill,
+        ziel: zielAusIpc(args.harness, args.ort),
+        ...(args.quelle === undefined ? {} : { quelle: args.quelle }),
+        lokal: args.ort.art === 'arbeitsverzeichnis',
+    })));
+    ipcMain.handle('hmgr:linkEntfernen', async (_event, args) => auffangen(async () => anwendungsfaelle.linkEntfernen({
+        skill: args.skill,
+        ziel: zielAusIpc(args.harness, args.ort),
+        lokal: args.ort.art === 'arbeitsverzeichnis',
+    })));
+    ipcMain.handle('hmgr:eintragIgnorieren', async (_event, args) => auffangen(async () => anwendungsfaelle.eintragIgnorieren({ ziel: zielAusIpc(args.harness, args.ort), name: args.name })));
+    ipcMain.handle('hmgr:eintragBeachten', async (_event, args) => auffangen(async () => anwendungsfaelle.eintragBeachten({ ziel: zielAusIpc(args.harness, args.ort), name: args.name })));
+    // Auch die Übernahme legt Links und schriebe ohne `lokal` den Zeiger (E31 über linkAusFund), sie
+    // trifft also dieselbe Sperre wie link (E57). In der GUI arbeitet sie darum wie die CLI mit
+    // --local (F32), sonst bräche der Knopf an jedem gebundenen Arbeitsverzeichnis ab.
+    ipcMain.handle('hmgr:uebernehmen', async (_event, args) => auffangen(async () => anwendungsfaelle.uebernehmen({
+        ziel: zielAusIpc(args.harness, args.ort),
+        ...(args.name === undefined ? {} : { name: args.name }),
+        probelauf: args.probelauf,
+        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: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
+    // nie ein echter Systemdialog aufgehen: sofort null, wie bei Abbruch.
+    ipcMain.handle('hmgr:verzeichnisWaehlen', async () => auffangen(async () => {
+        if (smoketest || hauptfenster === null)
+            return null;
+        const ergebnis = await dialog.showOpenDialog(hauptfenster, {
+            properties: ['openDirectory', 'createDirectory'],
+        });
+        if (ergebnis.canceled || ergebnis.filePaths.length === 0)
+            return null;
+        return ergebnis.filePaths[0] ?? null;
+    }));
+    // Harness-Schalter im Einstellungen-Modal (E38, GRILL.md Entwurfskritik 4).
+    ipcMain.handle('hmgr:harnessTypen', async () => auffangen(async () => anwendungsfaelle.harnessTypen()));
+    ipcMain.handle('hmgr:aktiveHarnesses', async () => auffangen(async () => anwendungsfaelle.aktiveHarnesses()));
+    // Für den Vermerk „nicht installiert" an den Schaltern (E42).
+    ipcMain.handle('hmgr:nichtVorhandeneHarnesses', async () => auffangen(async () => anwendungsfaelle.nichtVorhandeneHarnesses()));
+    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)));
+    // 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))));
+    ipcMain.handle('hmgr:skillOrdnerLoeschen', async (_event, args) => auffangen(async () => anwendungsfaelle.skillOrdnerLoeschen(zielAusIpc(args.harness, args.ort), args.pfad)));
+    // Quellen-Icon (E60): nur im Main-Prozess geladen, als data-URL geliefert (CSP erlaubt img-src
+    // data:). Im Smoke-Test nie ein Netzzugriff: sofort null, der Renderer zeigt dann das generische
+    // Symbol. Ein Fehlschlag wirft nie (auffangen fängt ihn, iconFuerQuelle selbst wirft ohnehin nicht).
+    ipcMain.handle('hmgr:icon', async (_event, quelleText) => auffangen(async () => {
+        if (smoketest)
+            return null;
+        return iconFuerQuelle(quelleAusText(quelleText), { cacheVerzeichnis: iconCacheVerzeichnis });
+    }));
+    // 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 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));
+        if (entscheidung.art === 'browser')
+            await shell.openExternal(entscheidung.url);
+        else if (entscheidung.art === 'ordner') {
+            const info = await stat(entscheidung.pfad).catch(() => undefined);
+            if (info === undefined)
+                throw new Error(`Es gibt „${entscheidung.pfad}" nicht (mehr).`);
+            if (info.isDirectory())
+                await shell.openPath(entscheidung.pfad);
+            else
+                shell.showItemInFolder(entscheidung.pfad);
+        }
+        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,
+        height: 860,
+        minWidth: 860,
+        minHeight: 560,
+        backgroundColor: '#E3E7E0', // --platte, verhindert einen weißen Blitz beim Start
+        // 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.
+        show: !smoketest,
+        webPreferences: {
+            preload: path.join(hierVerzeichnis, 'preload.cjs'),
+            contextIsolation: true,
+            nodeIntegration: false,
+            sandbox: true,
+        },
+    });
+    hauptfenster.on('closed', () => {
+        hauptfenster = null;
+    });
+    // Renderer-Konsole im Main-Log, für Fehlersuche und den Smoke-Test.
+    hauptfenster.webContents.on('console-message', (event) => {
+        console.log(`[renderer] ${event.message}`);
+    });
+    // Nur für den Smoke-Test (scripts/gui-smoke-test.ts): ein DOM-Auszug im Log, danach Ende.
+    if (smoketest) {
+        const fenster = hauptfenster;
+        fenster.webContents.once('did-finish-load', () => {
+            setTimeout(() => {
+                void fenster.webContents
+                    .executeJavaScript(`(async () => {
+              // Einstellungen-Modal (E40 R2): öffnen, die Harness-Schalter ablesen, wieder schließen.
+              document.getElementById('einstellungen')?.click();
+              var einstellungenOffen = document.getElementById('d-einstellungen')?.open === true;
+              var harnessSchalter = Array.from(document.querySelectorAll('#harnessliste input[type=checkbox]'))
+                .map((i) => i.dataset.harness + ':' + i.checked)
+                .join(',');
+              // 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.
+              var quelleneuVorhanden = document.getElementById('quelleneu') !== null;
+              var dialogeQuelleVorhanden =
+                document.getElementById('d-quelle') !== null && document.getElementById('d-quelle-vergessen') !== null;
+              var quelleFehler = null;
+              var dQuelleOffenNachOeffnen = false;
+              var dQuelleOffenNachAbbrechen = true;
+              try {
+                document.getElementById('quelleneu')?.click();
+                dQuelleOffenNachOeffnen = document.getElementById('d-quelle')?.open === true;
+                document.querySelector('#d-quelle button[value="abbruch"]')?.click();
+                dQuelleOffenNachAbbrechen = document.getElementById('d-quelle')?.open === true;
+              } catch (fehler) {
+                quelleFehler = String(fehler);
+              }
+              // Aufräum-Angebot nach Quelle entfernen (E58): kein echter Lauf (der würde Checkouts
+              // und Links wirklich löschen), nur ob der Dialog existiert und sich öffnen und über
+              // Behalten schließen lässt, ohne Fehler.
+              var dialogQuelleAufraeumenVorhanden = document.getElementById('d-quelle-aufraeumen') !== null;
+              var quelleAufraeumenFehler = null;
+              var dQuelleAufraeumenOffenNachOeffnen = false;
+              var dQuelleAufraeumenOffenNachBehalten = true;
+              try {
+                var dQuelleAufraeumen = document.getElementById('d-quelle-aufraeumen');
+                dQuelleAufraeumen?.showModal();
+                dQuelleAufraeumenOffenNachOeffnen = dQuelleAufraeumen?.open === true;
+                document.querySelector('#d-quelle-aufraeumen button[value="behalten"]')?.click();
+                dQuelleAufraeumenOffenNachBehalten = dQuelleAufraeumen?.open === true;
+              } catch (fehler) {
+                quelleAufraeumenFehler = String(fehler);
+              }
+              // Anzeigename der Quelle (E59): die Einstellungen-Liste zeigt den abgeleiteten Namen
+              // „skills-repo" statt der vollen Fixture-URL, das Namensfeld im Hinzufügen-Dialog gibt
+              // es zusätzlich zum URL/Pfad-Feld.
+              var quellenlisteNamen = Array.from(document.querySelectorAll('#quellenliste b'))
+                .map((b) => b.textContent)
+                .join(',');
+              var dqNameVorhanden = document.getElementById('dq-name') !== null;
+              // Umbenennen (E59): der Knopf je Quelle öffnet den Dialog mit dem aktuellen Namen im
+              // Feld, Abbrechen schließt ihn wieder. Beide Knöpfe der Zeile liegen zusammen in
+              // einem Kasten, sonst lägen sie im Grid übereinander.
+              var quellenknoepfeZahl = document.querySelectorAll('#quellenliste .quellenknoepfe').length;
+              var quelleUmbenennenFehler = null;
+              var dQuUOffenNachOeffnen = false;
+              var dQuUName = null;
+              var dQuUOffenNachAbbrechen = true;
+              try {
+                var dQuU = document.getElementById('d-quelle-umbenennen');
+                // E60: der Umbenennen-Knopf ist jetzt ein Stift-Icon-Knopf ohne Text (Klasse
+                // „umbenennen", aria-label statt Beschriftung).
+                document.querySelector('#quellenliste .umbenennen')?.click();
+                dQuUOffenNachOeffnen = dQuU?.open === true;
+                dQuUName = document.getElementById('dqu-name')?.value ?? null;
+                document.querySelector('#d-quelle-umbenennen button[value="abbruch"]')?.click();
+                dQuUOffenNachAbbrechen = dQuU?.open === true;
+              } catch (fehler) {
+                quelleUmbenennenFehler = String(fehler);
+              }
+              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
+              // Profil, Öffnen und Abbrechen ohne Fehler, nach dem Muster der d-quelle-Prüfungen.
+              var konfigzeileEl = document.querySelector('.konfigzeile');
+              var konfigzeileText = konfigzeileEl ? konfigzeileEl.textContent.replace(/\\s+/g, ' ').trim() : null;
+              var skillOrdnerFehler = null;
+              var dSkillordnerOffenNachOeffnen = false;
+              var dSkillordnerOffenNachAbbrechen = true;
+              try {
+                var festlegenKnopf = Array.from(document.querySelectorAll('button'))
+                  .find((b) => b.textContent === 'Skill-Ordner festlegen …');
+                festlegenKnopf?.click();
+                dSkillordnerOffenNachOeffnen = document.getElementById('d-skillordner')?.open === true;
+                document.querySelector('#d-skillordner button[value="abbruch"]')?.click();
+                dSkillordnerOffenNachAbbrechen = document.getElementById('d-skillordner')?.open === true;
+              } catch (fehler) {
+                skillOrdnerFehler = String(fehler);
+              }
+              // 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;
+              // 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
+                ?.replace(/\\s+/g, ' ').trim() ?? null;
+              var aufklapp = document.querySelector('#katalog .zeile .aufklappknopf');
+              var katalogDetailsZu = document.querySelector('#katalog .zeile .skillkoerper')?.hidden ?? null;
+              aufklapp?.click();
+              var katalogAufgeklappt = aufklapp?.getAttribute('aria-expanded') ?? null;
+              var katalogDetails = document.querySelector('#katalog .zeile .skillkoerper:not([hidden])')?.textContent
+                ?.replace(/\\s+/g, ' ').trim() ?? null;
+              // Sicherheitsrelevante Marken (F11): Hooks und Werkzeuge tragen die warnende Klasse.
+              var katalogMarkenWarnend = Array.from(document.querySelectorAll('#katalog .zeile .merker.warnend'))
+                .map((m) => m.textContent).join(',');
+              // Skills-hinzufügen-Dialog (F13): dieselben Marken an der Wahlzeile.
+              var dskKnopf = Array.from(document.querySelectorAll('button'))
+                .find((b) => b.textContent === 'Skills hinzufügen');
+              var dskMarken = null;
+              if (dskKnopf) {
+                dskKnopf.click();
+                dskMarken = document.querySelector('#dsk-liste .wahlzeile .marken')?.textContent
+                  ?.replace(/\\s+/g, ' ').trim() ?? null;
+                document.getElementById('d-skills')?.close();
+              }
+              // 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;
+              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'),
+                document.fonts.load('500 16px "JetBrains Mono"'),
+              ]);
+              return JSON.stringify({
+                titel: document.title,
+                kopfzahlen: document.getElementById('kopfzahlen')?.textContent,
+                zielliste: document.getElementById('zielliste')?.textContent?.replace(/\\s+/g, ' ').trim().slice(0, 600),
+                meldung: document.getElementById('meldungtext')?.textContent,
+                einstellungenOffen,
+                harnessSchalter,
+                zielBeschreibung,
+                zielMarken,
+                zielManuellVorhanden,
+                zahnradVorhanden,
+                katalogBeschreibung,
+                katalogMarken,
+                katalogDetailsZu,
+                katalogAufgeklappt,
+                katalogDetails,
+                katalogMarkenWarnend,
+                dskMarken,
+                interGeladen: document.fonts.check('400 16px Inter'),
+                monoGeladen: document.fonts.check('500 16px "JetBrains Mono"'),
+                quelleneuVorhanden,
+                dialogeQuelleVorhanden,
+                quellenlisteNamen,
+                dqNameVorhanden,
+                quellenknoepfeZahl,
+                dQuUOffenNachOeffnen,
+                dQuUName,
+                dQuUOffenNachAbbrechen,
+                quelleUmbenennenFehler,
+                dQuelleOffenNachOeffnen,
+                dQuelleOffenNachAbbrechen,
+                quelleFehler,
+                dialogQuelleAufraeumenVorhanden,
+                dQuelleAufraeumenOffenNachOeffnen,
+                dQuelleAufraeumenOffenNachBehalten,
+                quelleAufraeumenFehler,
+                // Hinweiszeile im Erfolgsdialog (E26, F32): vorhanden und im Ruhezustand leer.
+                deHinweisVorhanden: document.getElementById('de-hinweis') !== null,
+                deHinweisVerborgen: document.getElementById('de-hinweis')?.hidden === true,
+                konfigzeileText,
+                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,
+                agentsKarteVorhanden,
+                agentsMcpAbschnittVorhanden,
+                agentsMcpKnopfVorhanden,
+                dMcpHinzuOffenNachOeffnen,
+                dMcpHinzuOffenNachAbbrechen,
+                dmhListeText,
+                dmhFehler,
+              });
+            })()`)
+                    .then((auszug) => console.log(`[smoke] DOM-Auszug: ${auszug}`))
+                    .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.
+    if (!smoketest) {
+        const fenster = hauptfenster;
+        fenster.webContents.once('did-finish-load', () => {
+            fenster.webContents.send('hmgr:aktualisierenAnstossen');
+        });
+        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();
+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();
+});