hmgr 0.0.5 → 0.0.6

package/dist/adapter/marketplace-json.js

@@ -1,5 +1,6 @@
 // .claude-plugin/marketplace.json lesen (E24, HARNESS-FAKTEN „Plugins und Marketplaces").
 // Nur die beiden dokumentierten Formen, alles andere wird abgelehnt statt geraten.
+import { ohneBom } from "./datei-text.js";
 /** Standardordner für die Skills eines Plugins, relativ zu seiner Quelle. */
 const SKILL_ORDNER = 'skills';
 export class MarketplaceUnbekannteForm extends Error {
@@ -80,7 +81,7 @@ function pluginLesen(roh, dateien) {
 export function marketplaceLesen(text, dateien) {
     let daten;
     try {
-        daten = JSON.parse(text);
+        daten = JSON.parse(ohneBom(text));
     }
     catch (fehler) {
         throw new MarketplaceUnbekannteForm(`kein gültiges JSON (${fehler instanceof Error ? fehler.message : fehler})`);

package/dist/adapter/mcp-katalog.js

@@ -0,0 +1,124 @@
+// Liest den persönlichen MCP-Katalog ~/.hmgr/mcp.yaml (E61). hmgr schreibt ihn nie.
+import { readFile } from 'node:fs/promises';
+import { parseDocument } from 'yaml';
+import { McpKatalogFehler } from "../kern/modell.js";
+const STDIO_FELDER = new Set(['command', 'args', 'env']);
+const URL_FELDER = new Set(['url', 'headers']);
+function fehlertext(fehler) {
+    return fehler instanceof Error ? fehler.message : String(fehler);
+}
+function istObjekt(wert) {
+    return typeof wert === 'object' && wert !== null && !Array.isArray(wert);
+}
+/** Ein optionales Textfeld: fehlt es oder ist es leer, bleibt es weg, kein Fehler. */
+function feldText(pfad, name, o, feld) {
+    if (!(feld in o))
+        return undefined;
+    const wert = o[feld];
+    if (typeof wert !== 'string')
+        throw new McpKatalogFehler(pfad, `Eintrag „${name}": Feld „${feld}" muss Text sein`);
+    const getrimmt = wert.trim();
+    return getrimmt.length === 0 ? undefined : wert;
+}
+/** Eine Zeichenkette-zu-Zeichenkette-Map wie `env` oder `headers`, oder undefined ohne das Feld. */
+function mapLesen(pfad, name, wert, feld) {
+    if (wert === undefined)
+        return undefined;
+    if (!istObjekt(wert))
+        throw new McpKatalogFehler(pfad, `Eintrag „${name}": konfig.${feld} muss ein Objekt sein`);
+    const ergebnis = {};
+    for (const [k, v] of Object.entries(wert)) {
+        if (typeof v !== 'string')
+            throw new McpKatalogFehler(pfad, `Eintrag „${name}": konfig.${feld}.${k} muss Text sein`);
+        ergebnis[k] = v;
+    }
+    return ergebnis;
+}
+/** Eine Liste von Zeichenketten wie `args`, oder undefined ohne das Feld. */
+function argsLesen(pfad, name, wert) {
+    if (wert === undefined)
+        return undefined;
+    if (!Array.isArray(wert))
+        throw new McpKatalogFehler(pfad, `Eintrag „${name}": konfig.args muss eine Liste sein`);
+    return wert.map((eintrag, i) => {
+        if (typeof eintrag !== 'string')
+            throw new McpKatalogFehler(pfad, `Eintrag „${name}": konfig.args[${i}] muss Text sein`);
+        return eintrag;
+    });
+}
+function konfigLesen(pfad, name, k) {
+    const hatCommand = 'command' in k;
+    const hatUrl = 'url' in k;
+    if (hatCommand && hatUrl)
+        throw new McpKatalogFehler(pfad, `Eintrag „${name}": konfig darf nicht zugleich „command" und „url" haben`);
+    if (hatCommand) {
+        for (const feld of Object.keys(k))
+            if (!STDIO_FELDER.has(feld))
+                throw new McpKatalogFehler(pfad, `Eintrag „${name}": unbekanntes Feld „${feld}" in konfig`);
+        const command = k['command'];
+        if (typeof command !== 'string' || command.trim().length === 0)
+            throw new McpKatalogFehler(pfad, `Eintrag „${name}": konfig.command muss nicht leerer Text sein`);
+        const args = argsLesen(pfad, name, k['args']);
+        const env = mapLesen(pfad, name, k['env'], 'env');
+        return { command, ...(args === undefined ? {} : { args }), ...(env === undefined ? {} : { env }) };
+    }
+    if (hatUrl) {
+        for (const feld of Object.keys(k))
+            if (!URL_FELDER.has(feld))
+                throw new McpKatalogFehler(pfad, `Eintrag „${name}": unbekanntes Feld „${feld}" in konfig`);
+        const url = k['url'];
+        if (typeof url !== 'string' || url.trim().length === 0)
+            throw new McpKatalogFehler(pfad, `Eintrag „${name}": konfig.url muss nicht leerer Text sein`);
+        const headers = mapLesen(pfad, name, k['headers'], 'headers');
+        return { url, ...(headers === undefined ? {} : { headers }) };
+    }
+    throw new McpKatalogFehler(pfad, `Eintrag „${name}": konfig braucht entweder „command" oder „url"`);
+}
+function eintragLesen(pfad, name, roh) {
+    if (!istObjekt(roh))
+        throw new McpKatalogFehler(pfad, `Eintrag „${name}" ist kein Objekt`);
+    const beschreibung = roh['beschreibung'];
+    if (typeof beschreibung !== 'string' || beschreibung.trim().length === 0)
+        throw new McpKatalogFehler(pfad, `Eintrag „${name}" braucht eine Beschreibung (Feld „beschreibung")`);
+    const homepage = feldText(pfad, name, roh, 'homepage');
+    const notizen = feldText(pfad, name, roh, 'notizen');
+    const konfigRoh = roh['konfig'];
+    if (!istObjekt(konfigRoh))
+        throw new McpKatalogFehler(pfad, `Eintrag „${name}" braucht einen Konfigblock (Feld „konfig")`);
+    const konfig = konfigLesen(pfad, name, konfigRoh);
+    return {
+        name,
+        beschreibung,
+        ...(homepage === undefined ? {} : { homepage }),
+        ...(notizen === undefined ? {} : { notizen }),
+        konfig,
+    };
+}
+export class DateiMcpKatalog {
+    pfad;
+    constructor(pfad) {
+        this.pfad = pfad;
+    }
+    /** Fehlende Datei: leerer Katalog, kein Fehler. Kaputtes YAML oder falsches Format: Fehler mit Pfad. */
+    async lesen() {
+        let text;
+        try {
+            text = await readFile(this.pfad, 'utf8');
+        }
+        catch {
+            return [];
+        }
+        let daten;
+        try {
+            daten = parseDocument(text, { strict: true }).toJS();
+        }
+        catch (fehler) {
+            throw new McpKatalogFehler(this.pfad, `kaputtes YAML: ${fehlertext(fehler)}`);
+        }
+        if (daten === null || daten === undefined)
+            return [];
+        if (!istObjekt(daten))
+            throw new McpKatalogFehler(this.pfad, 'die Datei muss ein Objekt mit einem Eintrag je MCP-Name sein');
+        return Object.entries(daten).map(([name, roh]) => eintragLesen(this.pfad, name, roh));
+    }
+}

package/dist/adapter/quelle-text.js

@@ -1,8 +1,17 @@
 import path from 'node:path';
+import { istWindowsLaufwerkspfad } from "../kern/quelle-ort.js";
 export { quelleAlsText } from "../kern/modell.js";
-/** URL heißt Git-Quelle mit Checkout, ein nackter Pfad heißt lokale Arbeitskopie ohne Clone (B11). */
+/**
+ * URL heißt Git-Quelle mit Checkout, ein nackter Pfad heißt lokale Arbeitskopie ohne Clone (B11).
+ *
+ * Ein Windows-Laufwerkspfad ist ein nackter Pfad (E65/B12): `C:\work\quelle` traf sonst die
+ * scp-Regel `host:pfad` — Host „C" — und `hmgr source add C:\work\quelle` legte die Arbeitskopie
+ * als Git-Quelle mit Remote an statt als lokale. Sichtbar wurde das am Anzeigenamen „\work\quelle".
+ */
 export function quelleAusText(text) {
     const roh = text.trim();
+    if (istWindowsLaufwerkspfad(roh))
+        return { art: 'lokal', pfad: path.resolve(roh) };
     if (roh.includes('://') || /^(?:[^@/\s]+@)?[^@/:\s]+:[^/\s]/.test(roh))
         return { art: 'git', url: roh };
     return { art: 'lokal', pfad: path.resolve(roh) };

package/dist/adapter/skill-md.js

@@ -1,9 +1,10 @@
 // Name, Beschreibung und Besonderheiten eines Skills aus dem Frontmatter der SKILL.md (E32, E39, E55).
 import { parse } from 'yaml';
+import { ohneBom } from "./datei-text.js";
 export const SKILL_DATEI = 'SKILL.md';
 /** Der Block zwischen der ersten Zeile `---` und der nächsten Zeile `---`. Fehlt er, undefined. */
 function frontmatter(inhalt) {
-    const zeilen = inhalt.replace(/^\uFEFF/, '').split('\n');
+    const zeilen = ohneBom(inhalt).split('\n');
     if (zeilen[0]?.trimEnd() !== '---')
         return undefined;
     for (let i = 1; i < zeilen.length; i += 1)

package/dist/adapter/umgebung.js

@@ -0,0 +1,43 @@
+// Prozess-Umgebung und .env-Dateien, für die F39-Prüfung beim MCP-Einhängen (E61).
+import { readFile } from 'node:fs/promises';
+export class ProzessUmgebung {
+    env;
+    constructor(env = process.env) {
+        this.env = env;
+    }
+    variablen() {
+        const ergebnis = {};
+        for (const [name, wert] of Object.entries(this.env))
+            if (wert !== undefined)
+                ergebnis[name] = wert;
+        return ergebnis;
+    }
+    /**
+     * Liest NAME=wert-Zeilen. Leere Zeilen und solche, die mit „#" beginnen, zählen nicht. Werte in
+     * einfachen oder doppelten Anführungszeichen werden davon befreit, sonst unverändert übernommen.
+     */
+    async envDatei(pfad) {
+        let text;
+        try {
+            text = await readFile(pfad, 'utf8');
+        }
+        catch {
+            return {};
+        }
+        const ergebnis = {};
+        for (const zeile of text.split('\n')) {
+            const getrimmt = zeile.trim();
+            if (getrimmt.length === 0 || getrimmt.startsWith('#'))
+                continue;
+            const trenner = getrimmt.indexOf('=');
+            if (trenner <= 0)
+                continue;
+            const name = getrimmt.slice(0, trenner).trim();
+            let wert = getrimmt.slice(trenner + 1).trim();
+            if (wert.length >= 2 && ((wert.startsWith('"') && wert.endsWith('"')) || (wert.startsWith("'") && wert.endsWith("'"))))
+                wert = wert.slice(1, -1);
+            ergebnis[name] = wert;
+        }
+        return ergebnis;
+    }
+}

package/dist/adapter/vergleich.js

@@ -0,0 +1,20 @@
+// Gemeinsames Modul der Adapter: Vergleich zweier aus YAML oder JSON gelesener Werte.
+/**
+ * Tiefer Vergleich, ohne Rücksicht auf die Schlüsselreihenfolge. Gebraucht, wo ein Adapter einen
+ * schon vorhandenen MCP-Eintrag gegen den Katalogblock hält (E61): gleicher Block heißt „schon
+ * eingehängt", ein abweichender wird nie stillschweigend überschrieben.
+ */
+export function tiefGleich(a, b) {
+    if (a === b)
+        return true;
+    if (Array.isArray(a) || Array.isArray(b))
+        return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((v, i) => tiefGleich(v, b[i]));
+    if (typeof a === 'object' && a !== null && typeof b === 'object' && b !== null) {
+        const ak = Object.keys(a).sort();
+        const bk = Object.keys(b).sort();
+        if (ak.length !== bk.length || ak.some((k, i) => k !== bk[i]))
+            return false;
+        return ak.every((k) => tiefGleich(a[k], b[k]));
+    }
+    return false;
+}

package/dist/adapter/zustand-json.js

@@ -2,6 +2,7 @@
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { leererZustand } from "../ports/zustand.js";
+import { ohneBom } from "./datei-text.js";
 export class ZustandJson {
     pfad;
     constructor(pfad) {
@@ -11,7 +12,7 @@ export class ZustandJson {
         const roh = await readFile(this.pfad, 'utf8').catch(() => undefined);
         if (roh === undefined)
             return leererZustand();
-        const daten = JSON.parse(roh);
+        const daten = JSON.parse(ohneBom(roh));
         return {
             quellen: (daten.quellen ?? []),
             arbeitsverzeichnisse: (daten.arbeitsverzeichnisse ?? []),

package/dist/cli/hilfe.js

@@ -22,6 +22,10 @@ hmgr <kommando> [schalter]
   plugin add <name>         Plugin in ein Ziel legen (installieren oder Skills verlinken)
   plugin remove <name>      Plugin aus einem Ziel entfernen
   plugin list               Plugins der Marketplaces aller Quellen
+  mcp add <name>            MCP-Server aus dem Katalog in ein Ziel einhängen
+  mcp remove <name>         MCP-Server aus einem Ziel aushängen
+  mcp migrate <name>        MCP-Server aus der geteilten .mcp.json in den privaten Scope übernehmen
+  mcp list                  Katalog-Einträge zeigen, mit wo sie eingehängt sind
   sync [pfad]               Ziel auf den Stand seines Zeigers bringen
   update                    Alle Checkouts aktualisieren
   status                    Ist-Zustand der Ziele
@@ -226,6 +230,99 @@ Häufige Fälle:
   kann nur die Quelle beheben.
 
 Siehe auch: hmgr help source, hmgr help sync`;
+const MCP = `hmgr mcp add <name> [schalter]
+hmgr mcp remove <name> [schalter]
+hmgr mcp migrate <name> [schalter]
+hmgr mcp list
+
+Ein MCP-Server ist ein Eintrag im persönlichen Katalog ~/.hmgr/mcp.yaml, nicht in einer Quelle: kein
+Download, keine Installation, kein Update. hmgr liest den Katalog nur, er wird von Hand oder von
+einem LLM gepflegt, das den MCP ohnehin gerade einrichtet. mcp add hängt einen Katalog-Eintrag in
+ein Ziel ein (Projekt oder global), mcp remove hängt ihn wieder aus, mcp list zeigt den Katalog mit
+je Eintrag, wo er eingehängt ist, dazu Einträge, die in Harness-Konfigurationen liegen, aber nicht
+im Katalog stehen (nur genannt, hmgr fasst sie nicht an). mcp list sieht dabei in den Homes und
+Profilen der Harnesses nach und in den Arbeitsverzeichnissen, die hmgr kennt (hmgr dir add); ein
+MCP in einem Verzeichnis, das hmgr nicht kennt, taucht dort nicht auf.
+
+Format von ~/.hmgr/mcp.yaml: ein Objekt, Schlüssel ist der MCP-Name. Je Eintrag:
+
+  beschreibung   Pflicht, kurzer Text
+  homepage       optional, URL
+  notizen        optional, mehrzeilig
+  konfig         Pflicht: entweder command (Pflicht), optional args und env,
+                 oder url (Pflicht), optional headers
+
+Andere Schlüssel im konfig-Block sind ein Fehler, mit Eintrag und Feld in der Meldung. Secrets
+stehen als \${VAR}- oder \${env:VAR}-Verweise im Block, nie im Klartext; aufgelöst werden sie vom
+Harness gegen dessen Umgebung, hmgr prüft beim Einhängen nur, ob die Variablen gesetzt sind, und
+warnt sonst. Fehlt die Datei, ist der Katalog leer, kein Fehler; kaputtes YAML ist ein Fehler mit
+dem Dateipfad.
+
+Beispiel:
+
+  teamwork:
+    beschreibung: Teamwork.com Projektmanagement
+    homepage: https://teamwork.com
+    notizen: |
+      Erfordert TEAMWORK_API_KEY, siehe Teamwork-Profil.
+    konfig:
+      command: npx
+      args: ["-y", "@teamwork/mcp-server"]
+      env:
+        TEAMWORK_API_KEY: \${TEAMWORK_API_KEY}
+
+  context7:
+    beschreibung: Context7 Doku-Suche
+    konfig:
+      url: https://mcp.context7.com/mcp
+      headers:
+        Authorization: Bearer \${env:CONTEXT7_TOKEN}
+
+Die Fähigkeit hängt am Harness-Adapter, nicht am Namen (E16): claude-code kennt Projekt (Scope
+local, nie die geteilte .mcp.json der Projektwurzel, das bleibt Team-Sache wie beim Zeiger, E57) und
+global (Scope user). Hermes kennt nur global, mcp_servers in seiner config.yaml (Home oder Profil
+mit --ort profil:<name>); ein Projekt-Ziel ist bei Hermes ein Fehler, es kennt keine Projektebene für
+MCPs. agents kennt MCP-Server gar nicht.
+
+mcp migrate ist der einzige Weg, auf dem hmgr die geteilte .mcp.json anfasst (E64): der Eintrag
+wandert 1:1 aus der Datei in deinen privaten Scope am selben Ort und wird dort gelöscht. Auch ein
+Eintrag, der nicht im Katalog steht, lässt sich so übernehmen — der Konfigblock kommt aus der Datei,
+nicht aus dem Katalog. Ist die Datei mit dem Team geteilt, verlieren die anderen den Server, sobald
+die Änderung committet ist. Nur claude-code hat eine solche Datei und nur an einem
+Arbeitsverzeichnis. Gearbeitet wird in zwei Schritten, erst eintragen, dann entfernen: bricht der
+zweite ab, steht der Eintrag doppelt statt gar nicht mehr, und die Meldung sagt, was zu tun bleibt.
+
+Nach dem Einhängen/Aushängen nennt hmgr den Weg zur Wirkung: Claude Code übernimmt die Änderung erst
+mit der nächsten Sitzung, Hermes lädt seine config.yaml selbst nach, dafür gibt es keinen Hinweis.
+
+Fehlende \${VAR}-Verweise beim Einhängen sind kein Abbruch, nur eine Warnung (F39): hmgr kann nicht
+wissen, was die Shell beim Start des Harness setzt. Geprüft wird gegen die eigene Prozess-Umgebung
+und, bei einem Hermes-Ziel, zusätzlich gegen <hermes-home>/.env.
+
+Schalter (add, remove und migrate):
+  --harness <name>    claude-code oder hermes, Standard claude-code
+  --ort <ort>         home, dir:<pfad> oder profil:<name>, Standard home
+
+Beispiele:
+  hmgr mcp list
+  hmgr mcp add teamwork --ort dir:.
+  hmgr mcp add context7 --harness hermes --ort profil:researcher
+  hmgr mcp remove teamwork --ort dir:.
+  hmgr mcp migrate kollegen-tool --ort dir:.
+
+Häufige Fälle:
+  „steht nicht im Katalog": hmgr mcp list zeigt die bekannten Namen, ~/.hmgr/mcp.yaml pflegt sie.
+  „kennt keine MCP-Server": nur claude-code und hermes haben diese Fähigkeit, agents nicht.
+  „kennt für MCP-Server den Ort … nicht – Hermes kennt keine Projektebene für MCPs": bei Hermes
+  --ort home oder --ort profil:<name> nutzen, kein dir:<pfad>.
+  „liegt schon ein MCP-Server …, der nicht von hmgr stammt oder vom Katalogblock abweicht": von Hand
+  angleichen oder hmgr mcp remove, dann erneut versuchen.
+  „steht in der geteilten …/.mcp.json": mcp remove fasst sie nicht an, hmgr mcp migrate <name> holt
+  den Eintrag in den privaten Scope und löscht ihn aus der Datei.
+  „gibt es keine geteilte Konfigurationsdatei": mcp migrate geht nur mit --harness claude-code und
+  --ort dir:<pfad>.
+
+Siehe auch: hmgr help harness, hmgr help status`;
 const SYNC = `hmgr sync [pfad]
 
 Bringt ein Arbeitsverzeichnis auf den Stand seines Zeigers: fehlende Quellen übernehmen, fehlende
@@ -359,6 +456,7 @@ const THEMEN = new Map([
     ['unlink', UNLINK],
     ['adopt', ADOPT],
     ['plugin', PLUGIN],
+    ['mcp', MCP],
     ['sync', SYNC],
     ['update', UPDATE],
     ['status', STATUS],

package/dist/cli/main.js

@@ -5,15 +5,17 @@ import { realpathSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { pathToFileURL } from 'node:url';
 import { Anwendungsfaelle } from "../kern/anwendungsfaelle.js";
-import { AbhaengigkeitFehlt, EinschraenkungOhneZeiger, HarnessNichtVorhanden, HarnessTypUnbekannt, KeinPassenderRef, NameBelegt, OrtNichtUnterstuetzt, PluginMehrdeutig, PluginUnbekannt, QuelleAufraeumenLokaleAenderungen, QuelleNameBelegt, QuelleUnbekannt, SkillMehrdeutig, SkillOrdnerBereitsVerwaltet, SkillOrdnerFaehigkeitFehlt, SkillOrdnerNichtVerwaltet, SkillOrdnerUngueltig, SkillUnbekannt, ZeigerMehrdeutig, ZeigerSchreibenGesperrt, pluginSchluessel, quelleName, quelleSchluessel, } from "../kern/modell.js";
+import { AbhaengigkeitFehlt, EinschraenkungOhneZeiger, HarnessNichtVorhanden, HarnessTypUnbekannt, KeinPassenderRef, LinkAnlegenFehlgeschlagen, McpAbweichenderEintrag, McpEbeneNichtUnterstuetzt, McpFaehigkeitFehlt, McpKatalogFehler, McpNichtInGeteilterDatei, McpNurGeteilterFundort, McpUebernahmeNichtMoeglich, McpUebernahmeUnvollstaendig, McpUnbekannt, NameBelegt, OrtNichtUnterstuetzt, PluginMehrdeutig, PluginUnbekannt, QuelleAufraeumenLokaleAenderungen, QuelleNameBelegt, QuelleUnbekannt, SkillMehrdeutig, SkillOrdnerBereitsVerwaltet, SkillOrdnerFaehigkeitFehlt, SkillOrdnerNichtVerwaltet, SkillOrdnerUngueltig, SkillUnbekannt, ZeigerMehrdeutig, ZeigerSchreibenGesperrt, pluginSchluessel, quelleName, quelleSchluessel, } from "../kern/modell.js";
 import { Agents } from "../adapter/agents.js";
 import { ClaudeCode } from "../adapter/claude-code.js";
 import { Hermes } from "../adapter/hermes.js";
 import { ComposerZeiger } from "../adapter/composer.js";
 import { DateisystemZiele } from "../adapter/dateisystem.js";
 import { GitQuellen } from "../adapter/git.js";
+import { DateiMcpKatalog } from "../adapter/mcp-katalog.js";
 import { quelleAlsText, quelleAusText } from "../adapter/quelle-text.js";
 import { TerminalRueckfrage } from "../adapter/terminal.js";
+import { ProzessUmgebung } from "../adapter/umgebung.js";
 import { ZustandJson } from "../adapter/zustand-json.js";
 import { HILFE, hilfeText } from "./hilfe.js";
 export function umgebungLesen(env = process.env) {
@@ -38,6 +40,8 @@ export function bauen(umgebung, optionen = {}) {
         zeiger: new ComposerZeiger(),
         zustand,
         rueckfrage: optionen.rueckfrage ?? new TerminalRueckfrage(),
+        mcpKatalog: new DateiMcpKatalog(path.join(umgebung.hmgrHome, 'mcp.yaml')),
+        umgebung: optionen.umgebung ?? new ProzessUmgebung(),
     };
     return { anwendungsfaelle: new Anwendungsfaelle(ports), ports };
 }
@@ -55,6 +59,7 @@ const SCHALTER = {
     unlink: { werte: ['harness', 'ort', 'composer'], flaggen: ['local', 'lokal'] },
     adopt: { werte: ['harness', 'ort', 'composer'], flaggen: ['local', 'lokal', 'probelauf'] },
     plugin: { werte: ['harness', 'ort', 'composer', 'quelle'], flaggen: ['local', 'lokal'] },
+    mcp: { werte: ['harness', 'ort'], flaggen: [] },
     sync: { werte: [], flaggen: [] },
     update: { werte: [], flaggen: [] },
     status: { werte: [], flaggen: [] },
@@ -82,6 +87,13 @@ const UNTERKOMMANDOS = {
         remove: { woerter: 2, schalter: ['harness', 'ort', 'composer', 'local', 'lokal'] },
         list: { woerter: 1, schalter: [] },
     },
+    mcp: {
+        add: { woerter: 2, schalter: ['harness', 'ort'] },
+        remove: { woerter: 2, schalter: ['harness', 'ort'] },
+        // Übernehmen (E64): dieselben Ziel-Schalter wie add und remove.
+        migrate: { woerter: 2, schalter: ['harness', 'ort'] },
+        list: { woerter: 1, schalter: [] },
+    },
     harness: {
         list: { woerter: 1, schalter: [] },
         enable: { woerter: 2, schalter: [] },
@@ -207,7 +219,7 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
                 console.log(quelleAlsText(quelle) === quelleAlsText(genannt)
                     ? 'Quelle ist schon bekannt, keine zweite angelegt.'
                     : `Quelle ist schon bekannt, geführt als ${quelleAlsText(quelle)}. Keine zweite angelegt.`);
-            console.log(`Quelle ${quelleAlsText(quelle)} (${quelle.art}) als „${quelleName(quelle)}", ${skills.length} Skills:`);
+            console.log(`Quelle ${quelleAlsText(quelle)} (${quelle.art}) als „${quelleName(quelle)}", ${skills.length} ${skills.length === 1 ? 'Skill' : 'Skills'}:`);
             for (const skill of skills) {
                 const beschreibung = skill.beschreibung === undefined ? '' : `  ${kappen(skill.beschreibung)}`;
                 console.log(`  ${skill.name}  ${skill.pfad}${beschreibung}`);
@@ -478,6 +490,64 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
                 console.log(`  ${zeile}`);
         return 0;
     }
+    if (kommando === 'mcp') {
+        const schalter = schalterLesen(argv.slice(1), 'mcp');
+        unterkommandoPruefen('mcp', schalter);
+        const { rest, werte } = schalter;
+        const unterkommando = rest[0];
+        if (unterkommando === 'list') {
+            const uebersicht = await anwendungsfaelle.mcpUebersicht();
+            if (uebersicht.katalog.length === 0)
+                console.log('Kein MCP im Katalog. hmgr help mcp zeigt das Format von ~/.hmgr/mcp.yaml.');
+            for (const { eintrag, eingehaengt, geteilteFundorte } of uebersicht.katalog) {
+                console.log(`${eintrag.name}  ${eintrag.beschreibung}`);
+                if (eingehaengt.length === 0 && geteilteFundorte.length === 0)
+                    console.log('  nirgends eingehängt');
+                for (const ziel of eingehaengt)
+                    console.log(`  ${ziel.harness}  ${beschreibeOrt(ziel.ort)}`);
+                // Geteilte, nur lesbare Fundorte (E61-Nachtrag): eigens gekennzeichnet, hmgr fasst sie nicht an.
+                for (const f of geteilteFundorte)
+                    console.log(`  ${f.ziel.harness}  ${beschreibeOrt(f.ziel.ort)}  ${f.datei} · Scope ${f.scope} (geteilt, hmgr fasst sie nicht an)`);
+            }
+            if (uebersicht.unbekannt.length > 0 || uebersicht.unbekannteGeteilteFundorte.length > 0) {
+                console.log('Nicht im Katalog, aber eingehängt (hmgr fasst sie nicht an):');
+                for (const { ziel, name } of uebersicht.unbekannt)
+                    console.log(`  ${name}  ${ziel.harness}  ${beschreibeOrt(ziel.ort)}`);
+                for (const f of uebersicht.unbekannteGeteilteFundorte)
+                    console.log(`  ${f.name}  ${f.ziel.harness}  ${beschreibeOrt(f.ziel.ort)}  ${f.datei} · Scope ${f.scope}`);
+            }
+            return 0;
+        }
+        if (unterkommando !== 'add' && unterkommando !== 'remove' && unterkommando !== 'migrate')
+            throw new Error(`${unterkommando === undefined ? 'mcp braucht ein Unterkommando' : `Unbekanntes Unterkommando „${unterkommando}" für mcp`}: mcp add <name>, mcp remove <name>, mcp migrate <name> oder mcp list. hmgr help mcp zeigt Beispiele.`);
+        const name = rest[1];
+        if (name === undefined)
+            throw new Error(`mcp ${unterkommando} braucht einen MCP-Namen. hmgr mcp list zeigt die Katalog-Einträge.`);
+        const ziel = { harness: werte.get('harness') ?? 'claude-code', ort: ortLesen(werte.get('ort')) };
+        // Übernehmen (E64): der Name muss nicht im Katalog stehen, der Block kommt aus der geteilten Datei.
+        if (unterkommando === 'migrate') {
+            const ergebnis = await anwendungsfaelle.mcpUebernehmen({ name, ziel });
+            console.log(`MCP ${ergebnis.name} in den privaten Scope von ${ziel.harness} ${beschreibeOrt(ziel.ort)} übernommen `
+                + `und aus ${ergebnis.datei} entfernt.`);
+            if (ergebnis.hinweis !== undefined)
+                console.log(`  ${ergebnis.hinweis}`);
+            return 0;
+        }
+        if (unterkommando === 'add') {
+            const ergebnis = await anwendungsfaelle.mcpEinhaengen({ name, ziel });
+            console.log(`MCP ${ergebnis.eintrag.name} eingehängt in ${ziel.harness} ${beschreibeOrt(ziel.ort)}.`);
+            if (ergebnis.hinweis !== undefined)
+                console.log(`  ${ergebnis.hinweis}`);
+            if (ergebnis.warnung !== undefined)
+                console.log(`  ${ergebnis.warnung}`);
+            return 0;
+        }
+        const ergebnis = await anwendungsfaelle.mcpAushaengen({ name, ziel });
+        console.log(`MCP ${ergebnis.eintrag.name} ausgehängt aus ${ziel.harness} ${beschreibeOrt(ziel.ort)}.`);
+        if (ergebnis.hinweis !== undefined)
+            console.log(`  ${ergebnis.hinweis}`);
+        return 0;
+    }
     if (kommando === 'sync') {
         const { rest } = schalterLesen(argv.slice(1), 'sync');
         restPruefen(rest, 1, 'sync');
@@ -691,6 +761,7 @@ function beschreibeOrt(ort) {
 }
 function istModellFehler(fehler) {
     return (fehler instanceof NameBelegt ||
+        fehler instanceof LinkAnlegenFehlgeschlagen ||
         fehler instanceof SkillMehrdeutig ||
         fehler instanceof SkillUnbekannt ||
         fehler instanceof OrtNichtUnterstuetzt ||
@@ -709,7 +780,16 @@ function istModellFehler(fehler) {
         fehler instanceof SkillOrdnerFaehigkeitFehlt ||
         fehler instanceof SkillOrdnerBereitsVerwaltet ||
         fehler instanceof SkillOrdnerNichtVerwaltet ||
-        fehler instanceof SkillOrdnerUngueltig);
+        fehler instanceof SkillOrdnerUngueltig ||
+        fehler instanceof McpUnbekannt ||
+        fehler instanceof McpFaehigkeitFehlt ||
+        fehler instanceof McpEbeneNichtUnterstuetzt ||
+        fehler instanceof McpAbweichenderEintrag ||
+        fehler instanceof McpKatalogFehler ||
+        fehler instanceof McpNurGeteilterFundort ||
+        fehler instanceof McpUebernahmeNichtMoeglich ||
+        fehler instanceof McpNichtInGeteilterDatei ||
+        fehler instanceof McpUebernahmeUnvollstaendig);
 }
 /**
  * Der nächste Schritt zu einem Fehler aus dem Kern. Die Fehlertexte selbst bleiben, wie das Modell
@@ -752,6 +832,20 @@ function naechsterSchritt(fehler) {
         return fehler.grund === 'ausserhalb'
             ? 'Der Pfad muss unterhalb des Hermes-Home liegen.'
             : 'Das ist Hermes\' eigener Skill-Ordner, ein anderer Pfad muss her.';
+    if (fehler instanceof McpUnbekannt)
+        return 'hmgr mcp list zeigt die Katalog-Einträge. Gepflegt wird der Katalog in ~/.hmgr/mcp.yaml, hmgr help mcp zeigt das Format.';
+    if (fehler instanceof McpFaehigkeitFehlt)
+        return 'Nur claude-code und hermes kennen MCP-Server.';
+    if (fehler instanceof McpEbeneNichtUnterstuetzt)
+        return 'claude-code kennt --ort home und --ort dir:<pfad>, hermes --ort home und --ort profil:<name>.';
+    if (fehler instanceof McpAbweichenderEintrag)
+        return 'Erst von Hand angleichen oder mit hmgr mcp remove entfernen, dann erneut versuchen.';
+    if (fehler instanceof McpKatalogFehler)
+        return '~/.hmgr/mcp.yaml prüfen und korrigieren, hmgr help mcp zeigt das Format.';
+    if (fehler instanceof McpUebernahmeNichtMoeglich)
+        return 'Eine geteilte .mcp.json kennt nur claude-code, und nur an einem Arbeitsverzeichnis: --harness claude-code --ort dir:<pfad>.';
+    if (fehler instanceof McpNichtInGeteilterDatei)
+        return 'hmgr mcp list zeigt, welche Namen dort stehen; mcp migrate übernimmt nur Einträge aus der geteilten Datei.';
     return undefined;
 }
 export async function main(argv, umgebung) {

package/dist/gui/beobachter.js

@@ -0,0 +1,108 @@
+// Datei-Watcher für externe Änderungen (E62): main.ts verdrahtet nur, die eigentliche Logik ist
+// hier rein (kein Electron-Import), nach dem Muster von oeffnen.ts und icons.ts, damit sie ohne
+// Electron testbar ist.
+//
+// Beobachtet wird eine feste Liste von Pfaden (hmgr-Zustand, MCP-Katalog, Harness-MCP-Konfigs,
+// .env-Dateien, siehe main.ts). Zwei Eigenheiten des Dateisystems bestimmen den Aufbau, beide am
+// laufenden System gemessen (macOS 25, Node 22):
+//
+// 1. Beobachtet wird nie die Datei selbst, sondern immer ihr Elternverzeichnis mit einem Filter auf
+//    die Dateinamen darin. `fs.watch` auf eine Datei hängt am Inode und wird nach dem ersten
+//    atomaren Ersetzen (schreiben in eine Temp-Datei, dann `rename` darüber) dauerhaft taub — kein
+//    weiteres Event, weder bei erneutem `rename` noch beim Schreiben an Ort und Stelle. Genau so
+//    schreiben viele Editoren, und so wird auch `~/.claude.json` ersetzt. Ein Watcher auf das
+//    Verzeichnis überlebt das und meldet den Dateinamen mit. Nebenbei deckt er Dateien ab, die beim
+//    Start noch gar nicht existieren: tauchen sie später auf, fängt derselbe Watcher es ab.
+//
+// 2. Ein Event heißt nicht, dass sich etwas geändert hat. `claude plugin list` — das hmgr bei jedem
+//    Anzeige-Aufbau je Claude-Code-Ziel ruft — ersetzt `~/.claude.json` jedes Mal per `rename`, mit
+//    unverändertem Inhalt. Ohne Gegenmaßnahme entstünde daraus eine Endlosschleife: Anzeige laden →
+//    Datei ersetzt → Watcher feuert → Anzeige laden. Darum stößt der Watcher erst an, wenn sich der
+//    Inhalt mindestens einer beobachteten Datei gegenüber dem letzten Stand wirklich unterscheidet.
+//
+// Fehlt das Elternverzeichnis, bleibt der Pfad unbeobachtet, bis ihn der nächste Fokus-Reload (E62)
+// ohnehin erfasst. Mehrere Events in kurzer Folge (ein Editor schreibt beim Speichern oft mehrfach,
+// ein `rename` meldet mehrere Events) lösen genau einen Callback aus: jedes Event verschiebt einen
+// Timer um `entprellenMs` nach hinten, erst danach wird verglichen.
+import { readFileSync, watch } from 'node:fs';
+import { createHash } from 'node:crypto';
+import path from 'node:path';
+const STANDARD_ENTPRELLEN_MS = 400;
+/** Marke für eine Datei, die es (noch) nicht gibt — unterscheidbar von jedem echten Inhalt. */
+const FEHLT = 'fehlt';
+/** Fingerabdruck des Inhalts. Unlesbar (fehlend, keine Rechte) zählt als `FEHLT`, nicht als Änderung. */
+function fingerabdruck(pfad) {
+    try {
+        return createHash('sha256').update(readFileSync(pfad)).digest('hex');
+    }
+    catch {
+        return FEHLT;
+    }
+}
+/**
+ * Beobachtet `pfade` auf inhaltliche Änderungen und ruft `callback` entprellt auf. Doppelte Pfade
+ * werden nur einmal beobachtet, Pfade im selben Verzeichnis teilen sich einen Watcher.
+ */
+export function beobachten(pfade, callback, optionen = {}) {
+    const entprellenMs = optionen.entprellenMs ?? STANDARD_ENTPRELLEN_MS;
+    const watcher = [];
+    let timer;
+    let geschlossen = false;
+    const eindeutige = [...new Set(pfade)];
+    const stand = new Map(eindeutige.map((p) => [p, fingerabdruck(p)]));
+    /** Zieht den Stand nach und sagt, ob sich dabei etwas geändert hat. */
+    function hatSichGeaendert() {
+        let geaendert = false;
+        for (const pfad of eindeutige) {
+            const neu = fingerabdruck(pfad);
+            if (stand.get(pfad) !== neu) {
+                stand.set(pfad, neu);
+                geaendert = true;
+            }
+        }
+        return geaendert;
+    }
+    function anstossen() {
+        if (geschlossen)
+            return;
+        if (timer !== undefined)
+            clearTimeout(timer);
+        timer = setTimeout(() => {
+            timer = undefined;
+            if (geschlossen)
+                return;
+            if (hatSichGeaendert())
+                callback();
+        }, entprellenMs);
+    }
+    // Je Verzeichnis ein Watcher, der die dort gesuchten Dateinamen kennt.
+    const jeVerzeichnis = new Map();
+    for (const pfad of eindeutige) {
+        const verzeichnis = path.dirname(pfad);
+        const namen = jeVerzeichnis.get(verzeichnis) ?? new Set();
+        namen.add(path.basename(pfad));
+        jeVerzeichnis.set(verzeichnis, namen);
+    }
+    for (const [verzeichnis, namen] of jeVerzeichnis) {
+        try {
+            watcher.push(watch(verzeichnis, (_ereignis, geaenderterName) => {
+                // Ohne Namen (kommt vor, je nach Plattform) wird konservativ angestoßen; der
+                // Inhaltsvergleich entscheidet ohnehin.
+                if (geaenderterName === null || namen.has(path.basename(geaenderterName)))
+                    anstossen();
+            }));
+        }
+        catch {
+            // Das Verzeichnis fehlt: diese Pfade bleiben unbeobachtet (siehe Kommentar oben).
+        }
+    }
+    return {
+        close() {
+            geschlossen = true;
+            if (timer !== undefined)
+                clearTimeout(timer);
+            for (const w of watcher)
+                w.close();
+        },
+    };
+}