hmgr 0.0.5 → 0.0.6

package/dist/gui/renderer/styles.css

@@ -91,7 +91,7 @@ a{color:var(--signal-tief)}
 
 /* ---------- Quellen: Icon, Name, Sprung zur Quelle (E60) ---------- */
 /* Der Name bleibt ruhig, das kleine Pfeilsymbol traegt das Signalorange und sagt: das geht nach
-   draussen, zur Repo-Seite oder in den Finder. Keine Unterstreichung, die flackert in einer Tabelle
+   draussen, zur Repo-Seite oder in den Dateimanager. Keine Unterstreichung, die flackert in einer Tabelle
    mit vielen Zeilen. */
 .qlink{
   display:inline-flex;align-items:center;gap:5px;
@@ -192,6 +192,8 @@ a{color:var(--signal-tief)}
 .ansichtskopf p{margin-top:10px;color:var(--tinte-weich);font-size:17px}
 
 .werkzeuge{display:flex;flex-wrap:wrap;gap:12px;align-items:center;margin-bottom:18px}
+/* „Verzeichnis hinzufügen" unter der letzten Verzeichnis-Karte (2026-09-05). */
+.zielfussleiste{margin-top:18px}
 .suche{position:relative;flex:1 1 320px;min-width:260px}
 .suche input{
   width:100%;font:inherit;font-size:16px;padding:11px 14px 11px 44px;background:var(--blech);
@@ -371,6 +373,10 @@ img.hsymbol{border-radius:3px}
   display:-webkit-box;-webkit-box-orient:vertical;-webkit-line-clamp:2;overflow:hidden;
 }
 .linkliste .was.fehlt{color:var(--tinte-leise);font-style:italic}
+/* Beschreibung plus Frontmatter-Marken (E55) in einer Zelle: die Marken stehen unter der
+   geklammerten Beschreibung, nicht in ihr, sonst würde die Zeilen-Klammer sie abschneiden. */
+.linkliste .wasfeld{min-width:0}
+.linkliste .wasfeld .marken{margin-top:5px}
 .linkliste .quelle{display:flex;flex-wrap:wrap;align-items:center;gap:3px 9px;line-height:1.4}
 .linkliste .quelle .ref{font-family:var(--mono);font-size:16px;letter-spacing:-.012em;color:var(--tinte-leise)}
 /* Der Grund steht nur da, wenn er nicht „von Hand" heisst (der Normalfall entfällt ersatzlos): ein
@@ -602,7 +608,7 @@ dialog::backdrop{background:rgba(9,45,37,.62)}
   .linkliste li{grid-template-columns:20px minmax(0,1fr) auto;gap:3px 12px}
   .linkliste .repo{grid-column:1;grid-row:1}
   .linkliste .name{grid-column:2;grid-row:1}
-  .linkliste .was{grid-column:2;grid-row:2}
+  .linkliste .wasfeld{grid-column:2;grid-row:2}
   .linkliste .quelle{grid-column:2;grid-row:3}
   .linkliste .knopf.klein,.linkliste .kein-weg{grid-column:3;grid-row:1 / span 3;align-self:center}
   .linkliste .knopf.klein{margin-top:0}
@@ -636,3 +642,60 @@ dialog::backdrop{background:rgba(9,45,37,.62)}
   *,*::before,*::after{animation-duration:.01ms !important;animation-iteration-count:1 !important;transition-duration:.01ms !important}
   .zeile:hover{transform:none}
 }
+
+/* ---------- MCP (E61-Folgerunde) ---------- */
+/* Ein Katalog-Eintrag ist keine Ziel-Karte: er ist ein Ding, kein Ort, also traegt er keine
+   Emaille-Kopfzeile, sondern steht ganz auf Blech (entwurf/gui.html). Die Reihenfolge im Kasten ist
+   die Reihenfolge der Fragen: was ist das, wie verbindet es sich, was muss ich dazu wissen, wo
+   haengt es. */
+.mcpliste{display:flex;flex-direction:column;gap:14px}
+.mcp{background:var(--blech);border:1px solid var(--strich);border-radius:3px;padding:16px 18px}
+.mcpkopf{display:flex;flex-wrap:wrap;align-items:baseline;gap:7px 14px;margin-bottom:6px}
+.mcpkopf b{font-family:var(--schrift);font-weight:700;font-size:19px;letter-spacing:-.018em}
+.mcpkopf .knopf{margin-left:auto;align-self:center}
+.mcp .was{font-size:16px;color:var(--tinte-weich)}
+/* Der Konfigblock in einer Zeile: das Kennwort der Verbindung als Glied wie in der Plugin-Kette,
+   dahinter die Adresse bzw. das Kommando im Wortlaut. Hier stehen die ${VAR}-Verweise, deshalb
+   sitzt die Warnung direkt darunter. */
+.mcpkonfig{margin-top:11px;display:flex;flex-wrap:wrap;align-items:baseline;gap:7px 10px}
+.mcpkonfig .mono{color:var(--tinte-weich);overflow-wrap:anywhere}
+.mcp .ruhezeile{margin-top:10px;margin-bottom:0}
+
+/* Notizen sind das Langsame am Eintrag: sie stehen zugeklappt da und oeffnen sich nur, wenn jemand
+   sie sucht. Der Wortlaut bleibt, wie er in der mcp.yaml steht, Zeilenumbrueche eingeschlossen. */
+.notizen{margin-top:12px}
+.notizen summary{
+  display:inline-flex;align-items:center;gap:8px;width:max-content;
+  list-style:none;cursor:pointer;border-radius:2px;
+  font-family:var(--schrift);font-size:16px;color:var(--tinte-leise);
+  transition:color .12s ease;
+}
+.notizen summary::-webkit-details-marker{display:none}
+.notizen summary:hover{color:var(--tinte)}
+.notizen summary .keil{flex:none;width:11px;height:11px;transition:transform .14s ease}
+.notizen[open] summary .keil{transform:rotate(90deg)}
+.notizen p{
+  margin-top:9px;padding-left:13px;border-left:2px solid var(--strich);
+  font-size:16px;color:var(--tinte-weich);white-space:pre-line;max-width:62ch;
+}
+
+/* MCP an der Ziel-Karte (E61-GUI-Nachtrag), Gegenrichtung zur MCP-Ansicht (F46: die einzige Stelle,
+   die noch zeigt, wo ein Server hängt): eigener Abschnitt unter der Skill-Link-Tabelle, Name,
+   Beschreibung/Vermerk, Aktion rechtsbündig, flach in der Karte statt in einem eigenen Kasten. */
+.mcpkarteabschnitt{margin-top:16px;padding-top:14px;border-top:1px solid var(--strich)}
+.mcpkarteabschnitt > .etikett{display:block;margin-bottom:10px}
+.mcpkarteleer{margin:0;color:var(--tinte-leise);font-style:italic}
+.mcpkartezeilen{list-style:none;margin:0;padding:0;display:flex;flex-direction:column;gap:10px}
+.mcpkartezeilen li{display:flex;flex-wrap:wrap;align-items:center;gap:5px 14px}
+.mcpkartezeilen .name{font-family:var(--mono);font-size:16px;letter-spacing:-.012em;color:var(--tinte)}
+.mcpkartezeilen .was{font-size:16px;color:var(--tinte-weich)}
+.mcpkartezeilen .was.fehlt{color:var(--tinte-leise);font-style:italic}
+.mcpkartezeilen .knopf{margin-left:auto}
+.mcpkartezeilen .kein-weg{margin-left:auto;font-size:16px;color:var(--tinte-leise);text-align:right}
+/* Wo ein Eintrag steht (E64): kein margin-left:auto, sonst teilte er sich den freien Platz mit dem
+   Übernehmen-Knopf und stünde in der Mitte statt beim Text. */
+.mcpkartezeilen .geteiltvermerk{font-size:16px;color:var(--tinte-leise)}
+/* Leerer Katalog: keine Aktion, sondern der Weg zur Datei. */
+.startfeld.mcpstart{display:block}
+.startfeld.mcpstart p{max-width:62ch}
+.startfeld.mcpstart p + p{margin-top:11px}

package/dist/kern/anwendungsfaelle.js

@@ -1,8 +1,8 @@
 // Anwendungsfälle. Pfade werden hier nur als Zeichenketten normalisiert, gelesen wird über die Ports.
 import path from 'node:path';
-import { AbhaengigkeitFehlt, EinschraenkungOhneZeiger, FremderEintragUnbekannt, HarnessNichtVorhanden, HarnessTypUnbekannt, KeinPassenderRef, OrtNichtUnterstuetzt, PluginMehrdeutig, PluginUnbekannt, QuelleAufraeumenLokaleAenderungen, QuelleNameBelegt, QuelleUnbekannt, SkillMehrdeutig, SkillOrdnerBereitsVerwaltet, SkillOrdnerFaehigkeitFehlt, SkillOrdnerNichtVerwaltet, SkillUnbekannt, ZeigerMehrdeutig, ZeigerSchreibenGesperrt, marketplaceUrl, pluginSchluessel, pluginSchluesselZerlegen, quelleAlsText, quelleMitNamen, quelleName, quelleNameAbleiten, quelleNameFrei, quelleSchluessel, zielSchluessel, } from "./modell.js";
+import { AbhaengigkeitFehlt, EinschraenkungOhneZeiger, FremderEintragUnbekannt, HarnessNichtVorhanden, HarnessTypUnbekannt, KeinPassenderRef, McpEbeneNichtUnterstuetzt, McpFaehigkeitFehlt, McpUebernahmeNichtMoeglich, McpUnbekannt, OrtNichtUnterstuetzt, PluginMehrdeutig, PluginUnbekannt, QuelleAufraeumenLokaleAenderungen, QuelleNameBelegt, QuelleUnbekannt, SkillMehrdeutig, SkillOrdnerBereitsVerwaltet, SkillOrdnerFaehigkeitFehlt, SkillOrdnerNichtVerwaltet, SkillUnbekannt, ZeigerMehrdeutig, ZeigerSchreibenGesperrt, marketplaceUrl, pluginSchluessel, pluginSchluesselZerlegen, quelleAlsText, quelleMitNamen, quelleName, quelleNameAbleiten, quelleNameFrei, quelleSchluessel, zielSchluessel, } from "./modell.js";
 import { passenderRef } from "./version.js";
-import { kannIstRegistriert, kannPlugins, kannProfile, kannSkillOrdner, kannZurueckbauen, } from "../ports/harness.js";
+import { kannIstRegistriert, kannMcp, kannPlugins, kannProfile, kannSkillOrdner, kannZurueckbauen, } from "../ports/harness.js";
 /**
  * Frage vor dem Löschen, eine für alle Kandidaten (E28). Der Kern formuliert sie fertig, der
  * Adapter stellt sie: Anzahl und Pfade, damit der Nutzer sieht, worüber er entscheidet.
@@ -24,6 +24,22 @@ function ignorierterEintragGleich(i, args) {
 function fehlertext(fehler) {
     return fehler instanceof Error ? fehler.message : String(fehler);
 }
+/**
+ * `${VAR}`- und `${env:VAR}`-Verweise in einem MCP-Konfigblock, ohne Dubletten (E61, F39).
+ * Exportiert, damit die GUI dieselbe Prüfung für den Warn-Vermerk an der Katalog-Karte
+ * wiederverwenden kann (E61-Folgerunde), statt sie nachzubauen.
+ */
+export function variablenVerweise(konfig) {
+    const texte = 'command' in konfig
+        ? [konfig.command, ...(konfig.args ?? []), ...Object.values(konfig.env ?? {})]
+        : [konfig.url, ...Object.values(konfig.headers ?? {})];
+    const namen = new Set();
+    const muster = /\$\{(?:env:)?([A-Za-z_][A-Za-z0-9_]*)\}/g;
+    for (const text of texte)
+        for (const treffer of text.matchAll(muster))
+            namen.add(treffer[1]);
+    return [...namen];
+}
 /**
  * Quellenhinweis bei Mehrdeutigkeit (E12): Teilstring des Schlüssels oder der Schreibweise. Beides
  * zählt, damit `host/besitzer/repo` genauso greift wie ein Stück der URL, unter der die Quelle
@@ -174,6 +190,160 @@ export class Anwendungsfaelle {
         const harness = await this.harnessGeprueft(ziel.harness);
         await this.harnessMitSkillOrdner(harness.name).skillOrdnerLoeschen(ziel.ort, pfad);
     }
+    /** Ein Harness mit der Fähigkeit MCP-Server (E61), sonst `McpFaehigkeitFehlt`. */
+    harnessMitMcp(name) {
+        const harness = this.harness(name);
+        if (!kannMcp(harness))
+            throw new McpFaehigkeitFehlt(name);
+        return harness;
+    }
+    /** MCP-Katalog, unverändert wie in ~/.hmgr/mcp.yaml gepflegt (E61). hmgr schreibt ihn nie. */
+    async mcpKatalog() {
+        return await this.p.mcpKatalog.lesen();
+    }
+    async mcpEintragFinden(mcpName) {
+        const eintrag = (await this.p.mcpKatalog.lesen()).find((e) => e.name === mcpName);
+        if (eintrag === undefined)
+            throw new McpUnbekannt(mcpName);
+        return eintrag;
+    }
+    /**
+     * F39: fehlende `${VAR}`-Verweise als Warnung, nie als Abbruch. Geprüft wird gegen die eigene
+     * Prozess-Umgebung und, wenn die Fähigkeit eine `.env`-Datei nennt (Hermes), zusätzlich gegen sie.
+     */
+    async mcpVariablenWarnung(faehig, eintrag, ort) {
+        const verweise = variablenVerweise(eintrag.konfig);
+        if (verweise.length === 0)
+            return undefined;
+        const prozessEnv = this.p.umgebung.variablen();
+        const envPfad = faehig.mcp.envDatei?.(ort);
+        const zusatzEnv = envPfad === undefined ? {} : await this.p.umgebung.envDatei(envPfad);
+        const fehlend = verweise.filter((v) => !(v in prozessEnv) && !(v in zusatzEnv));
+        if (fehlend.length === 0)
+            return undefined;
+        const mehrzahl = fehlend.length > 1;
+        return (`hmgr kann nicht wissen, was die Shell beim Start des Harness setzt: ` +
+            `${mehrzahl ? 'Variablen' : 'Variable'} ${fehlend.join(', ')} ${mehrzahl ? 'sind' : 'ist'} weder in der ` +
+            'aktuellen Umgebung noch in einer bekannten .env-Datei zu finden.');
+    }
+    /**
+     * MCP einhängen (E61): Katalog-Eintrag an ein Ziel legen, Projekt oder global. Die Fähigkeit hängt
+     * am Adapter (E16): ein Harness ohne MCP-Fähigkeit oder ohne diese Ebene ist ein Fehler. Ein
+     * fehlender `${VAR}`-Verweis bricht nicht ab, sondern kommt als Warnung zurück (F39).
+     */
+    async mcpEinhaengen(args) {
+        const eintrag = await this.mcpEintragFinden(args.name);
+        const harness = await this.harnessGeprueft(args.ziel.harness);
+        const faehig = this.harnessMitMcp(harness.name);
+        if (!faehig.mcp.ebenen().includes(args.ziel.ort.art))
+            throw new McpEbeneNichtUnterstuetzt(harness.name, args.ziel.ort.art);
+        await faehig.mcp.einhaengen(eintrag.name, eintrag.konfig, args.ziel.ort);
+        const warnung = await this.mcpVariablenWarnung(faehig, eintrag, args.ziel.ort);
+        const hinweis = faehig.mcp.hinweisNachAenderung?.();
+        return {
+            eintrag,
+            ziel: args.ziel,
+            ...(hinweis === undefined ? {} : { hinweis }),
+            ...(warnung === undefined ? {} : { warnung }),
+        };
+    }
+    /** MCP aushängen (E61): Gegenstück zu `mcpEinhaengen`, ohne F39-Prüfung. */
+    async mcpAushaengen(args) {
+        const eintrag = await this.mcpEintragFinden(args.name);
+        const harness = await this.harnessGeprueft(args.ziel.harness);
+        const faehig = this.harnessMitMcp(harness.name);
+        if (!faehig.mcp.ebenen().includes(args.ziel.ort.art))
+            throw new McpEbeneNichtUnterstuetzt(harness.name, args.ziel.ort.art);
+        await faehig.mcp.aushaengen(eintrag.name, args.ziel.ort);
+        const hinweis = faehig.mcp.hinweisNachAenderung?.();
+        return { eintrag, ziel: args.ziel, ...(hinweis === undefined ? {} : { hinweis }) };
+    }
+    /**
+     * MCP übernehmen (E64, F48=O2): einen Eintrag aus der geteilten Konfigurationsdatei eines Ortes
+     * (bei Claude Code die `.mcp.json` der Projektwurzel) in den privaten Bereich desselben Ortes
+     * holen — eintragen und aus der geteilten Datei entfernen. Der Konfigblock kommt 1:1 aus der
+     * Datei, nicht aus dem Katalog: es gibt Einträge, die der Katalog nicht kennt, und beide Sorten
+     * müssen gehen. Die Fähigkeit hängt am Adapter (E16), nicht am Namen: fehlt sie, kennt dieser
+     * Harness-Typ keine geteilte Datei.
+     */
+    async mcpUebernehmen(args) {
+        const harness = await this.harnessGeprueft(args.ziel.harness);
+        const faehig = this.harnessMitMcp(harness.name);
+        const uebernehmen = faehig.mcp.geteiltenUebernehmen;
+        if (uebernehmen === undefined)
+            throw new McpUebernahmeNichtMoeglich(args.ziel);
+        const { datei } = await uebernehmen.call(faehig.mcp, args.name, args.ziel.ort);
+        const hinweis = faehig.mcp.hinweisNachAenderung?.();
+        return { name: args.name, ziel: args.ziel, datei, ...(hinweis === undefined ? {} : { hinweis }) };
+    }
+    /**
+     * Alle Orte, an denen MCP-Server grundsätzlich hängen können (E61): je Harness mit der Fähigkeit
+     * (E16, am Adapter abgefragt, nie am Namen) seine Ebenen aufgelöst zu tatsächlichen Zielen — Home,
+     * jedes bekannte Profil, jedes bekannte Arbeitsverzeichnis. Unabhängig davon, ob dort schon etwas
+     * hängt oder der Harness gerade aktiv ist (E38): das entscheidet der Aufrufer. Geteilt zwischen
+     * `mcpUebersicht` (dort mit `eingehaengte` abgeglichen) und `mcpPlaetze` (roh für den
+     * Einhängen-Dialog der GUI).
+     */
+    async mcpZiele() {
+        const ziele = [];
+        const zustand = await this.p.zustand.lesen();
+        for (const harness of await this.vorhandeneHarnesses()) {
+            if (!kannMcp(harness))
+                continue;
+            const ebenen = harness.mcp.ebenen();
+            if (ebenen.includes('home'))
+                ziele.push({ harness: harness.name, ort: { art: 'home' } });
+            if (ebenen.includes('profil') && kannProfile(harness))
+                for (const name of await harness.profile())
+                    ziele.push({ harness: harness.name, ort: { art: 'profil', name } });
+            if (ebenen.includes('arbeitsverzeichnis'))
+                for (const pfad of zustand.arbeitsverzeichnisse)
+                    ziele.push(arbeitsverzeichnisZiel(harness.name, pfad));
+        }
+        return ziele;
+    }
+    /**
+     * Die Plätze für den Einhängen-Dialog der GUI (E61-Folgerunde, F42): dieselbe Liste wie in
+     * `mcpUebersicht`, aber roh, ohne den Abgleich mit Katalog-Einträgen. Die Fähigkeit hängt am
+     * Adapter, nicht am Harness-Namen (E16): agents kommt nie vor, weil es `mcp` nicht implementiert.
+     */
+    async mcpPlaetze() {
+        return this.mcpZiele();
+    }
+    /**
+     * Übersicht für `hmgr mcp list` (E61): je Katalog-Eintrag, wo er eingehängt ist, dazu Einträge in
+     * Harness-Konfigurationen, die nicht im Katalog stehen (nur genannt, nicht angefasst).
+     */
+    async mcpUebersicht() {
+        const katalog = (await this.p.mcpKatalog.lesen()).map((eintrag) => ({
+            eintrag,
+            eingehaengt: [],
+            geteilteFundorte: [],
+        }));
+        const nachName = new Map(katalog.map((k) => [k.eintrag.name, k]));
+        const unbekannt = [];
+        const unbekannteGeteilteFundorte = [];
+        for (const ziel of await this.mcpZiele()) {
+            const faehig = this.harnessMitMcp(ziel.harness);
+            const namen = await faehig.mcp.eingehaengte(ziel.ort).catch(() => []);
+            for (const mcpName of namen) {
+                const eintrag = nachName.get(mcpName);
+                if (eintrag !== undefined)
+                    eintrag.eingehaengt.push(ziel);
+                else
+                    unbekannt.push({ ziel, name: mcpName });
+            }
+            const geteilt = (await faehig.mcp.geteilteFundorte?.(ziel.ort).catch(() => [])) ?? [];
+            for (const fundort of geteilt) {
+                const eintrag = nachName.get(fundort.name);
+                if (eintrag !== undefined)
+                    eintrag.geteilteFundorte.push({ ziel, datei: fundort.datei, scope: fundort.scope });
+                else
+                    unbekannteGeteilteFundorte.push({ ziel, name: fundort.name, datei: fundort.datei, scope: fundort.scope });
+            }
+        }
+        return { katalog, unbekannt, unbekannteGeteilteFundorte };
+    }
     /**
      * Säubern (E38): entfernt in allen Zielen dieses Harness-Typs (Home, Profile, bekannte
      * Arbeitsverzeichnisse) die von hmgr angelegten Links und baut harness-eigene Einträge zurück, die
@@ -1171,8 +1341,9 @@ export class Anwendungsfaelle {
             if (!enthalten)
                 return unbekannt('lokale-aenderungen');
             const quelle = normalisiert(quelleRoh);
-            // Der übliche Katalog (skills()) kennt nur Skills unter einem Unterverzeichnis (E11), ein
-            // Wurzel-Skill der ganzen Arbeitskopie kommt darin nicht vor. Er wird direkt gelesen (E48 a).
+            // Der Katalog (skills()) kennt einen Wurzel-Skill zwar seit dem E11-Nachtrag, aber er gilt
+            // für die geführte Quelle am gefragten Ref. Hier liegt eine fremde Arbeitskopie an Ort und
+            // Stelle: ihr Wurzel-Skill wird direkt von der Platte gelesen, ohne Clone (E48 a).
             const skill = await this.p.quellen.wurzelSkill(entryPfad).catch(() => null);
             if (skill === null)
                 return unbekannt('skill-unbekannt');

package/dist/kern/modell.js

@@ -63,10 +63,15 @@ export function quelleSchluessel(quelle) {
     const ort = urlOrt(quelle.url);
     return ort === undefined ? quelle.url : ortSchluessel(ort);
 }
-/** Letztes nicht leeres Segment eines Pfads oder einer URL, ohne abschließende Schrägstriche. */
+/**
+ * Letztes nicht leeres Segment eines Pfads oder einer URL, ohne abschließende Schrägstriche.
+ * Trenner sind `/` und `\` (E65/B7-Nachbar B8): unter Windows kommt der Pfad als `C:\work\quelle`
+ * herein und ergab sonst den Namen „\work\quelle". Ein POSIX-Ordnername mit Backslash wird dadurch
+ * zerteilt — akzeptiert, das hier ist reine Anzeige-Ableitung und geht in keinen Schlüssel ein.
+ */
 function letztesSegment(text) {
-    const bereinigt = text.replace(/\/+$/, '');
-    const segmente = bereinigt.split('/').filter((s) => s.length > 0);
+    const bereinigt = text.replace(/[/\\]+$/, '');
+    const segmente = bereinigt.split(/[/\\]/).filter((s) => s.length > 0);
     return segmente[segmente.length - 1] ?? bereinigt;
 }
 /**
@@ -130,6 +135,25 @@ export class NameBelegt extends Error {
         this.skillName = skillName;
     }
 }
+/**
+ * Der Link am Ziel ließ sich im Dateisystem nicht anlegen (E66). Ohne diesen Fehler käme ein roher
+ * Node-Stack beim Nutzer an, der weder Pfad noch Ausweg nennt. Der Handlungshinweis steht mit in
+ * der Meldung statt in `naechsterSchritt` der CLI: er nennt kein hmgr-Kommando, sondern eine
+ * Einstellung des Betriebssystems, und die GUI zeigt nur die Meldung.
+ */
+export class LinkAnlegenFehlgeschlagen extends Error {
+    linkPfad;
+    zielPfad;
+    ursache;
+    hinweis;
+    constructor(linkPfad, zielPfad, ursache, hinweis) {
+        super(`Der Link „${linkPfad}" auf „${zielPfad}" ließ sich nicht anlegen: ${ursache}\n${hinweis}`);
+        this.linkPfad = linkPfad;
+        this.zielPfad = zielPfad;
+        this.ursache = ursache;
+        this.hinweis = hinweis;
+    }
+}
 export class SkillMehrdeutig extends Error {
     name;
     quellen;
@@ -318,3 +342,117 @@ export class SkillOrdnerUngueltig extends Error {
         this.grund = grund;
     }
 }
+/** Ein Name, der im MCP-Katalog nicht steht (E61): mcp add und mcp remove kennen nur Katalog-Einträge. */
+export class McpUnbekannt extends Error {
+    mcpName;
+    constructor(mcpName) {
+        super(`MCP „${mcpName}" steht nicht im Katalog`);
+        this.mcpName = mcpName;
+    }
+}
+/** Ein Harness-Typ ohne die Fähigkeit MCP-Server (E61): heute nur claude-code und hermes. */
+export class McpFaehigkeitFehlt extends Error {
+    harness;
+    constructor(harness) {
+        super(`Harness ${harness} kennt keine MCP-Server`);
+        this.harness = harness;
+    }
+}
+/**
+ * Ein Ort, an dem dieser Harness-Typ keine MCP-Server verwaltet (E61): die Fähigkeit hängt am
+ * Adapter, nicht am Harness-Namen (E16), aber Hermes kennt grundsätzlich keine Projektebene für
+ * MCPs, das bekommt eine eigene Erklärung.
+ */
+export class McpEbeneNichtUnterstuetzt extends Error {
+    harness;
+    ort;
+    constructor(harness, ort) {
+        const erklaerung = harness === 'hermes' && ort === 'arbeitsverzeichnis' ? ' – Hermes kennt keine Projektebene für MCPs' : '';
+        super(`${harness} kennt für MCP-Server den Ort „${ort}" nicht${erklaerung}`);
+        this.harness = harness;
+        this.ort = ort;
+    }
+}
+/**
+ * Am Ziel liegt unter diesem Namen schon ein MCP-Server, den hmgr nicht selbst gelegt hat oder der
+ * vom Katalogblock abweicht (E61). hmgr überschreibt so etwas nicht stillschweigend.
+ */
+export class McpAbweichenderEintrag extends Error {
+    ziel;
+    mcpName;
+    constructor(ziel, mcpName) {
+        super(`In ${zielSchluessel(ziel)} liegt schon ein MCP-Server „${mcpName}", der nicht von hmgr stammt oder vom ` +
+            'Katalogblock abweicht. hmgr überschreibt ihn nicht stillschweigend.');
+        this.ziel = ziel;
+        this.mcpName = mcpName;
+    }
+}
+/**
+ * `aushaengen` trifft einen Namen, der nicht im schreibbaren Bereich liegt, aber in einem geteilten
+ * Fundort steht (E61-Nachtrag), etwa der `.mcp.json` einer Projektwurzel bei Claude Code. Anders als
+ * der reguläre idempotente Fall (nirgends eingehängt) bleibt hier tatsächlich ein Eintrag liegen:
+ * die Meldung darf das nicht als Erfolg verkaufen. Seit E64 gibt es dafür einen Weg in hmgr selbst,
+ * die Meldung nennt ihn statt „von Hand ändern".
+ */
+export class McpNurGeteilterFundort extends Error {
+    ziel;
+    mcpName;
+    datei;
+    constructor(ziel, mcpName, datei) {
+        super(`„${mcpName}" steht in der geteilten ${datei}, nicht in deiner privaten Konfiguration. `
+            + `hmgr mcp migrate ${mcpName} übernimmt ihn in den privaten Scope und entfernt ihn aus der Datei.`);
+        this.ziel = ziel;
+        this.mcpName = mcpName;
+        this.datei = datei;
+    }
+}
+/**
+ * Übernehmen (E64) an einem Ort, der keine geteilte Konfigurationsdatei kennt: ein Harness ohne
+ * diese Fähigkeit (Hermes kennt keine geteilte Datei) oder eine Ebene ohne sie (bei Claude Code hat
+ * nur ein Arbeitsverzeichnis eine `.mcp.json`, das Home nicht).
+ */
+export class McpUebernahmeNichtMoeglich extends Error {
+    ziel;
+    constructor(ziel) {
+        super(`In ${zielSchluessel(ziel)} gibt es keine geteilte Konfigurationsdatei, aus der hmgr einen MCP-Server übernehmen könnte.`);
+        this.ziel = ziel;
+    }
+}
+/** Übernehmen (E64) eines Namens, der in der geteilten Datei gar nicht steht. */
+export class McpNichtInGeteilterDatei extends Error {
+    ziel;
+    mcpName;
+    datei;
+    constructor(ziel, mcpName, datei) {
+        super(`„${mcpName}" steht nicht in ${datei}, da ist nichts zu übernehmen.`);
+        this.ziel = ziel;
+        this.mcpName = mcpName;
+        this.datei = datei;
+    }
+}
+/**
+ * Teilerfolg beim Übernehmen (E64): der Eintrag steht schon im privaten Scope, ließ sich aber nicht
+ * aus der geteilten Datei entfernen. Die Reihenfolge ist bewusst so gewählt (erst eintragen, dann
+ * entfernen), damit in diesem Fall nichts verloren ist. Die Meldung sagt, was der Nutzer jetzt
+ * vorfindet, statt nur den Fehlschlag zu nennen.
+ */
+export class McpUebernahmeUnvollstaendig extends Error {
+    ziel;
+    mcpName;
+    datei;
+    constructor(ziel, mcpName, datei, grund) {
+        super(`„${mcpName}" steht jetzt in deiner privaten Konfiguration, ließ sich aber nicht aus ${datei} entfernen: ${grund}. `
+            + 'Der Eintrag steht damit doppelt; wirksam ist der private. Entferne ihn aus der Datei von Hand, dann ist die Übernahme fertig.');
+        this.ziel = ziel;
+        this.mcpName = mcpName;
+        this.datei = datei;
+    }
+}
+/** Der MCP-Katalog ~/.hmgr/mcp.yaml lässt sich nicht lesen (E61): kaputtes YAML oder falsches Format. */
+export class McpKatalogFehler extends Error {
+    pfad;
+    constructor(pfad, grund) {
+        super(`MCP-Katalog ${pfad}: ${grund}`);
+        this.pfad = pfad;
+    }
+}

package/dist/kern/quelle-ort.js

@@ -12,9 +12,20 @@ export function ortAusSegmenten(host, segmente) {
     const besitzer = gefiltert[gefiltert.length - 2] ?? '_';
     return { host: host.toLowerCase(), besitzer, repo };
 }
+/**
+ * Ein Windows-Laufwerkspfad (E65/B12): ein einzelner ASCII-Buchstabe, ein Doppelpunkt und dann ein
+ * Trenner — `C:\work\quelle` oder `C:/work/quelle`. Genau diese Form sieht sonst aus wie eine
+ * scp-Kurzform `host:pfad` und wurde als Host „C" mit dem Pfad „\work\quelle" gelesen. Ein Hostname
+ * aus einem einzelnen Buchstaben ist theoretisch erlaubt, kommt als Git-Remote aber nicht vor; der
+ * Windows-Pfad kommt vor.
+ */
+export function istWindowsLaufwerkspfad(text) {
+    return /^[A-Za-z]:[\\/]/.test(text.trim());
+}
 /**
  * Zerlegt eine Git-URL: `git@host:besitzer/repo.git`, `ssh://git@host/besitzer/repo`,
- * `https://host/besitzer/repo.git`, `file:///pfad`. Ein Text, der keine URL ist, gibt undefined.
+ * `https://host/besitzer/repo.git`, `file:///pfad`. Ein Text, der keine URL ist, gibt undefined —
+ * darunter jeder nackte Pfad, der lokale POSIX-Pfad ebenso wie der Windows-Laufwerkspfad (E65/B12).
  */
 export function urlOrt(url) {
     const text = url.trim().replace(/\/+$/, '');
@@ -32,6 +43,8 @@ export function urlOrt(url) {
             return ortAusSegmenten('local', segmente);
         return ortAusSegmenten(zerlegt.hostname, segmente);
     }
+    if (istWindowsLaufwerkspfad(text))
+        return undefined;
     const scp = /^(?:[^@/]+@)?([^@/:]+):(.+)$/.exec(text);
     if (scp)
         return ortAusSegmenten(scp[1], scp[2].split('/'));

package/dist/ports/harness.js

@@ -4,6 +4,9 @@ export function kannProfile(h) {
 export function kannPlugins(h) {
     return h.plugins !== undefined;
 }
+export function kannMcp(h) {
+    return h.mcp !== undefined;
+}
 export function kannZurueckbauen(h) {
     return typeof h.zurueckbauen === 'function';
 }

package/dist/ports/mcp-katalog.js

@@ -0,0 +1 @@
+export {};

package/dist/ports/umgebung.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "hmgr",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "Harness Manager: Skills und Plugins für AI-Harnesses verwalten",
   "license": "MIT",
   "author": "Tim Kaufmann",
   "type": "module",
+  "main": "dist/gui/main.js",
   "bin": {
     "hmgr": "dist/cli/main.js"
   },
@@ -21,22 +22,63 @@
     "build": "tsc -p tsconfig.build.json && node scripts/copy-gui-assets.mjs",
     "gui": "npm run build && electron dist/gui/main.js",
     "gui:smoke": "npm run build && node scripts/gui-smoke-test.ts",
+    "gui:app": "npm run build && electron-builder --mac --arm64",
+    "gui:app:win": "npm run build && electron-builder --win --x64",
+    "gui:install": "npm run build && electron-builder --mac dir --arm64 && ditto release/mac-arm64/hmgr.app /Applications/hmgr.app",
     "test": "vitest run",
     "test:watch": "vitest",
     "type-check": "tsc --noEmit",
     "prepack": "npm run build"
   },
   "dependencies": {
+    "cross-spawn": "^7.0.6",
     "yaml": "^2.8.0"
   },
   "devDependencies": {
+    "@types/cross-spawn": "^6.0.6",
     "@types/node": "^24.0.0",
     "electron": "^44.0.0",
+    "electron-builder": "^26.15.3",
     "typescript": "^5.9.0",
     "vitest": "^3.2.0"
   },
   "repository": {
     "type": "git",
     "url": "git+https://gitea.timkaufmann.de/tim/hmgr.git"
+  },
+  "build": {
+    "appId": "de.timkaufmann.hmgr",
+    "productName": "hmgr",
+    "directories": {
+      "output": "release",
+      "buildResources": "build"
+    },
+    "files": [
+      "dist/**/*",
+      "package.json"
+    ],
+    "asar": true,
+    "mac": {
+      "category": "public.app-category.developer-tools",
+      "icon": "build/icon.icns",
+      "target": [
+        { "target": "dir", "arch": ["arm64"] },
+        { "target": "zip", "arch": ["arm64"] }
+      ],
+      "identity": null
+    },
+    "win": {
+      "icon": "build/icon.ico",
+      "target": [
+        { "target": "nsis", "arch": ["x64"] }
+      ]
+    },
+    "nsis": {
+      "oneClick": false,
+      "perMachine": false,
+      "allowElevation": false,
+      "allowToChangeInstallationDirectory": true,
+      "artifactName": "${productName}-Setup-${version}-${arch}.${ext}"
+    }
   }
 }