hmgr 0.0.5 → 0.0.6

package/dist/gui/login-pfad.js

@@ -0,0 +1,120 @@
+// Ermittelt den PATH einer Login-Shell des Nutzers (F47=O2). Grund: die gepackte hmgr.app startet
+// aus dem Finder mit dem macOS-Minimal-PATH (/usr/bin:/bin:/usr/sbin:/sbin), darin fehlt z. B.
+// ~/.local/bin mit der claude-CLI (E63). Reine Funktion, ohne Electron, nach dem Muster von
+// oeffnen.ts: main.ts ruft sie beim Start und übernimmt nur process.env.PATH.
+//
+// Unter Windows unterbleibt die Ermittlung ganz (E67): dort erbt ein aus dem Startmenü gestarteter
+// Prozess den vollen Benutzer- und System-PATH aus der Registry, es gibt keine Lücke zu schließen,
+// und eine Login-Shell im POSIX-Sinn gibt es nicht.
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+/** Zeitgrenze für die Shell. Gemessen auf picasso: `zsh -i -l -c` braucht ~2,0 s, das Doppelte
+    als Puffer reicht; wird sie überschritten, bleibt der PATH eben unverändert. */
+export const ZEITGRENZE_MS = 5_000;
+/**
+ * Standard-Ausführer: die angegebene Shell, stdin zu (sonst kann sie an einem Prompt hängen),
+ * stderr verworfen. Ein Fehlschlag wird zum Code, nicht zur Ausnahme — die PATH-Ermittlung darf
+ * die App nie zum Absturz bringen.
+ *
+ * Eigener Wecker statt der `timeout`-Option von `spawn`: die killt zwar die Shell, aber `close`
+ * feuert erst, wenn auch alle Erben die stdout-Pipe losgelassen haben — eine interaktive Shell
+ * kann Hintergrundprozesse hinterlassen. Der Wecker löst unabhängig davon auf, damit dieser Aufruf
+ * unter keinen Umständen länger als `ZEITGRENZE_MS` offen bleibt. `unref`, damit ein laufender
+ * Wecker das Beenden des Prozesses nicht aufhält.
+ */
+export const shellAusfuehrer = (shell, args) => new Promise((aufloesen) => {
+    let erledigt = false;
+    const beenden = (ergebnis) => {
+        if (erledigt)
+            return;
+        erledigt = true;
+        clearTimeout(wecker);
+        aufloesen(ergebnis);
+    };
+    const kind = spawn(shell, args, { stdio: ['ignore', 'pipe', 'ignore'] });
+    const wecker = setTimeout(() => {
+        kind.kill('SIGKILL');
+        beenden({ stdout: '', code: 1 });
+    }, ZEITGRENZE_MS);
+    wecker.unref();
+    let stdout = '';
+    kind.stdout.on('data', (d) => (stdout += d));
+    kind.on('error', () => beenden({ stdout: '', code: 1 }));
+    kind.on('close', (code) => beenden({ stdout, code: code ?? 1 }));
+});
+/**
+ * Liefert den PATH einer interaktiven Login-Shell des Nutzers, oder `undefined` bei Fehler,
+ * Zeitüberschreitung oder unplausibler Ausgabe. Shell aus `process.env.SHELL`, Fallback `/bin/zsh`
+ * (macOS-Default).
+ *
+ * `-i` ist nötig, nicht bequem: zsh liest `~/.zshrc` nur interaktiv, `-l` allein nur
+ * `~/.zshenv`/`~/.zprofile`/`~/.zlogin`. Wer wie auf picasso gar kein `~/.zprofile` hat und alle
+ * PATH-Erweiterungen in `~/.zshrc` stehen hat, bekäme mit `-l` allein nur das Ergebnis von
+ * `path_helper` zurück — also genau nicht `~/.local/bin` mit der claude-CLI, um die es hier geht
+ * (gemessen 2026-09-05: `-l` ohne `-i` liefert dort kein `~/.local/bin`, `-i -l` liefert es).
+ * Das Hänge-Risiko einer interaktiven Shell fängt der Ausführer ab: stdin zu und harte Zeitgrenze.
+ *
+ * Der Marker trennt den PATH von allem, was eine gesprächige `~/.zshrc` vorher auf stdout schreibt
+ * (Begrüßung, Versionshinweis, Prompt-Framework) — ohne ihn landete das Geschwätz im ersten
+ * PATH-Eintrag. Alles vor dem letzten Marker wird verworfen; fehlt er, gilt die Ausgabe als
+ * unbrauchbar.
+ */
+export const MARKER = '__hmgr_path__';
+export async function pathAusLoginShellErmitteln(ausfuehrer = shellAusfuehrer) {
+    const shell = process.env.SHELL && process.env.SHELL.trim() !== '' ? process.env.SHELL : '/bin/zsh';
+    const { stdout, code } = await ausfuehrer(shell, ['-i', '-l', '-c', `printf %s%s '${MARKER}' "$PATH"`]);
+    if (code !== 0)
+        return undefined;
+    const ab = stdout.lastIndexOf(MARKER);
+    if (ab === -1)
+        return undefined;
+    const pfad = stdout.slice(ab + MARKER.length).trim();
+    if (pfad === '' || !pfad.includes('/'))
+        return undefined;
+    return pfad;
+}
+/**
+ * Führt den Login-PATH vor den bestehenden PATH: neue Einträge zuerst, danach der bisherige PATH,
+ * Duplikate raus (erstes Vorkommen zählt). So verliert die App nie einen Eintrag aus dem
+ * bisherigen PATH, gewinnt aber die zusätzlichen Pfade der Login-Shell. Kein Voll-Env-Import
+ * anderer Variablen — nur der PATH wird übernommen, um Überraschungen zu vermeiden.
+ *
+ * Getrennt wird an `path.delimiter`, nicht fest an ':' (E67): unter Windows ist der Trenner ';',
+ * und ein hart verdrahteter Doppelpunkt zerlegte dort `C:\Windows;C:\Git\cmd` in „C", „\Windows;C"
+ * und „\Git\cmd" — der PATH wäre zerstört, sobald ein Laufwerksbuchstabe doppelt vorkommt und die
+ * Duplikatsprüfung zuschlägt. Aufgerufen wird die Funktion unter Windows zwar nicht mehr
+ * (`loginPathUebernehmen` steigt dort vorher aus), sie soll aber für sich genommen richtig sein.
+ * Der Trenner ist ein Parameter, damit das auf jedem Rechner prüfbar ist.
+ */
+export function pathZusammenfuehren(bisherigerPath, loginPath, trenner = path.delimiter) {
+    const eintraege = [...loginPath.split(trenner), ...(bisherigerPath ?? '').split(trenner)].filter((eintrag) => eintrag !== '');
+    const gesehen = new Set();
+    const ergebnis = [];
+    for (const eintrag of eintraege) {
+        if (gesehen.has(eintrag))
+            continue;
+        gesehen.add(eintrag);
+        ergebnis.push(eintrag);
+    }
+    return ergebnis.join(trenner);
+}
+/**
+ * Ermittelt den Login-PATH und setzt ihn (vorangestellt) auf `process.env.PATH`. Bei Fehler,
+ * Timeout oder leerer/unplausibler Ausgabe bleibt `process.env.PATH` unverändert — dieser Aufruf
+ * darf die App nie am Start hindern.
+ *
+ * Unter Windows passiert nichts (E67). Zwei Gründe, jeder für sich ausreichend: dort gibt es keine
+ * Login-Shell im POSIX-Sinn, `$SHELL` ist normalerweise gar nicht gesetzt und der Aufruf liefe
+ * gegen das nicht vorhandene `/bin/zsh` ins Leere; wo `$SHELL` doch gesetzt ist (Git-Bash- und
+ * MSYS-Umgebungen setzen es), käme ein POSIX-PATH mit ':' als Trenner zurück und würde dem echten
+ * Windows-PATH vorangestellt — kein Gewinn, aber ein Risiko. Die Plattform ist ein Parameter, damit
+ * der Ausstieg auf jedem Rechner prüfbar ist.
+ */
+export async function loginPathUebernehmen(ausfuehrer = shellAusfuehrer, plattform = process.platform) {
+    if (plattform === 'win32')
+        return;
+    const loginPath = await pathAusLoginShellErmitteln(ausfuehrer);
+    if (loginPath === undefined)
+        return;
+    process.env.PATH = pathZusammenfuehren(process.env.PATH, loginPath);
+}

package/dist/gui/main.js

@@ -2,19 +2,41 @@
 // 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 { 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 +45,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 +91,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() };
     }
@@ -97,8 +147,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),
@@ -230,7 +285,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 +302,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,
@@ -368,6 +499,9 @@ 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.
@@ -396,6 +530,137 @@ function fensterOeffnen() {
                   ?.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'),
@@ -409,6 +674,7 @@ function fensterOeffnen() {
                 einstellungenOffen,
                 harnessSchalter,
                 zielBeschreibung,
+                zielMarken,
                 zielManuellVorhanden,
                 zahnradVorhanden,
                 katalogBeschreibung,
@@ -443,6 +709,37 @@ 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,
+                agentsKarteVorhanden,
+                agentsMcpAbschnittVorhanden,
+                agentsMcpKnopfVorhanden,
+                dMcpHinzuOffenNachOeffnen,
+                dMcpHinzuOffenNachAbbrechen,
+                dmhListeText,
+                dmhFehler,
               });
             })()`)
                     .then((auszug) => console.log(`[smoke] DOM-Auszug: ${auszug}`))
@@ -461,20 +758,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();

package/dist/gui/mcp-ansicht.js

@@ -0,0 +1,57 @@
+// MCP-Ansicht der GUI (E61-Folgerunde): reine Umformung von Kern-Daten in IPC-taugliche, gewhiteliste
+// Objekte, ohne Electron — testbar wie oeffnen.ts und icons.ts. Der eigentliche IPC-Handler in
+// main.ts ruft diese Funktionen nur noch auf.
+import { variablenVerweise, } from "../kern/anwendungsfaelle.js";
+/** Katalog-Eintrag über IPC: die bekannten Felder, nichts ungefiltert durchgereicht (E40 R3). */
+export function mcpEintragSerialisieren(eintrag) {
+    return {
+        name: eintrag.name,
+        beschreibung: eintrag.beschreibung,
+        ...(eintrag.homepage === undefined ? {} : { homepage: eintrag.homepage }),
+        ...(eintrag.notizen === undefined ? {} : { notizen: eintrag.notizen }),
+        konfig: eintrag.konfig,
+    };
+}
+/**
+ * F39 an der Katalog-Karte: dieselbe Prüf-Funktion wie beim tatsächlichen Einhängen
+ * (`variablenVerweise`), hier aber nur gegen die übergebene Umgebung geprüft — ohne den
+ * ortsbezogenen `.env`-Abgleich, der ist ortsspezifisch und bleibt dem eigentlichen Einhängen
+ * vorbehalten (kommt von dort als `warnung` zurück).
+ */
+export function mcpFehlendeVariablen(eintrag, umgebung) {
+    return variablenVerweise(eintrag.konfig).filter((name) => !(name in umgebung) || umgebung[name] === undefined);
+}
+/** Übersicht über IPC (E61-Folgerunde): Katalog-Einträge whitelisted, dazu der F39-Vermerk je Karte. */
+export function mcpUebersichtSerialisieren(uebersicht, umgebung) {
+    return {
+        katalog: uebersicht.katalog.map((k) => ({
+            eintrag: mcpEintragSerialisieren(k.eintrag),
+            eingehaengt: k.eingehaengt,
+            geteilteFundorte: k.geteilteFundorte,
+            fehlendeVariablen: mcpFehlendeVariablen(k.eintrag, umgebung),
+        })),
+        unbekannt: uebersicht.unbekannt,
+        unbekannteGeteilteFundorte: uebersicht.unbekannteGeteilteFundorte,
+    };
+}
+/** Ergebnis von `mcpEinhaengen`/`mcpAushaengen` über IPC, whitelisted wie der Katalog-Eintrag. */
+export function mcpWirkungSerialisieren(ergebnis) {
+    return {
+        eintrag: mcpEintragSerialisieren(ergebnis.eintrag),
+        ziel: ergebnis.ziel,
+        ...(ergebnis.hinweis === undefined ? {} : { hinweis: ergebnis.hinweis }),
+        ...(ergebnis.warnung === undefined ? {} : { warnung: ergebnis.warnung }),
+    };
+}
+/**
+ * Ergebnis von `mcpUebernehmen` über IPC (E64). Kein Katalog-Eintrag darin: übernommen wird auch,
+ * was der Katalog nicht kennt, deshalb reicht der Name.
+ */
+export function mcpUebernahmeSerialisieren(ergebnis) {
+    return {
+        name: ergebnis.name,
+        ziel: ergebnis.ziel,
+        datei: ergebnis.datei,
+        ...(ergebnis.hinweis === undefined ? {} : { hinweis: ergebnis.hinweis }),
+    };
+}