hmgr 0.0.4 → 0.0.6

package/dist/cli/main.js

@@ -5,20 +5,27 @@ 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, KeinPassenderRef, NameBelegt, OrtNichtUnterstuetzt, PluginMehrdeutig, PluginUnbekannt, SkillMehrdeutig, SkillUnbekannt, ZeigerMehrdeutig, pluginSchluessel, } 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) {
     const home = env.HOME ?? homedir();
-    return { home, hmgrHome: env.HMGR_HOME ?? path.join(home, '.hmgr') };
+    const xdgStateHome = env.XDG_STATE_HOME;
+    return {
+        home,
+        hmgrHome: env.HMGR_HOME ?? path.join(home, '.hmgr'),
+        ...(xdgStateHome !== undefined && xdgStateHome.length > 0 ? { xdgStateHome } : {}),
+    };
 }
 export function bauen(umgebung, optionen = {}) {
     const zustand = new ZustandJson(path.join(umgebung.hmgrHome, 'state.json'));
@@ -29,10 +36,12 @@ export function bauen(umgebung, optionen = {}) {
     const ports = {
         harnesses: [claude, new Hermes(umgebung.home), new Agents(umgebung.home)],
         quellen: new GitQuellen(wurzel),
-        ziele: new DateisystemZiele(wurzel, zustand),
+        ziele: new DateisystemZiele(wurzel, zustand, umgebung.xdgStateHome),
         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 };
 }
@@ -41,7 +50,7 @@ export function bauen(umgebung, optionen = {}) {
  * steht nirgends, weil der Hilfe-Dispatch vor jedem schalterLesen läuft.
  */
 const SCHALTER = {
-    source: { werte: [], flaggen: [] },
+    source: { werte: ['name'], flaggen: [] },
     dir: { werte: ['composer'], flaggen: [] },
     link: {
         werte: ['harness', 'ort', 'composer', 'quelle', 'version'],
@@ -50,9 +59,11 @@ 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: [] },
+    harness: { werte: ['profil'], flaggen: [] },
 };
 /**
  * Was ein einzelnes Unterkommando von seiner Familie liest, gleichlautend mit ihrer Hilfe. Ohne
@@ -60,7 +71,12 @@ const SCHALTER = {
  * Schalter lesen.
  */
 const UNTERKOMMANDOS = {
-    source: { add: { woerter: 2 }, list: { woerter: 1 } },
+    source: {
+        add: { woerter: 2, schalter: ['name'] },
+        remove: { woerter: 2, schalter: [] },
+        rename: { woerter: 3, schalter: [] },
+        list: { woerter: 1, schalter: [] },
+    },
     dir: {
         add: { woerter: 2, schalter: ['composer'] },
         forget: { woerter: 2, schalter: [] },
@@ -71,6 +87,18 @@ 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: [] },
+        disable: { woerter: 2, schalter: [] },
+    },
 };
 function schalterLesen(args, kommando) {
     const erlaubt = SCHALTER[kommando];
@@ -145,6 +173,8 @@ const UEBERNAHME_GRUND = {
     'keine-url': 'Arbeitskopie ohne remote.origin.url',
     'kein-branch': 'Arbeitskopie ohne Branch (detached HEAD)',
     'skill-unbekannt': 'Pfad ist in der Quelle kein Skill',
+    'lokale-aenderungen': 'Ordner weicht von der Quelle ab',
+    'nicht-pruefbar': 'hmgr kann nicht prüfen, ob der Ordner der Quelle entspricht',
 };
 export async function ausfuehren(argv, umgebung, optionen = {}) {
     const { anwendungsfaelle, ports } = bauen(umgebung, optionen);
@@ -176,22 +206,24 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
     if (kommando === 'source') {
         const schalter = schalterLesen(argv.slice(1), 'source');
         unterkommandoPruefen('source', schalter);
-        const rest = schalter.rest;
+        const { rest, werte } = schalter;
         const unterkommando = rest[0];
         if (unterkommando === 'add') {
             const text = rest[1];
             if (text === undefined)
                 throw new Error('source add braucht eine URL oder einen Pfad, etwa hmgr source add https://example.com/skills.git');
             const genannt = quelleAusText(text);
-            const { quelle, skills, marketplace, bekannt } = await anwendungsfaelle.quelleHinzufuegen(genannt);
+            const { quelle, skills, marketplace, bekannt } = await anwendungsfaelle.quelleHinzufuegen(genannt, werte.get('name'));
             // Dieselbe Quelle in anderer Schreibweise legt keine zweite an (E36).
             if (bekannt)
                 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}), ${skills.length} Skills:`);
-            for (const skill of skills)
-                console.log(`  ${skill.name}  ${skill.pfad}`);
+            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}`);
+            }
             if (marketplace !== null) {
                 console.log(`Marketplace ${marketplace.name}, ${marketplace.plugins.length} Plugins:`);
                 for (const plugin of marketplace.plugins) {
@@ -201,15 +233,89 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
             }
             return 0;
         }
+        if (unterkommando === 'remove') {
+            const text = rest[1];
+            if (text === undefined)
+                throw new Error('source remove braucht eine URL oder einen Pfad. hmgr source list zeigt die bekannten Quellen.');
+            const genannt = quelleAusText(text);
+            // Inventar (E58) vor dem Vergessen erheben (F14): danach tragen die Links ihre Quelle nicht
+            // mehr. Bei unbekannter Quelle entfällt der Ziel-Scan, den Fehler wirft quelleEntfernen.
+            const key = quelleSchluessel(genannt);
+            // Die Rückfrage kommt jetzt VOR dem Vergessen (F31a), nennen muss sie die Quelle trotzdem
+            // unter ihrer geführten Schreibweise (E36), nicht unter der getippten.
+            const gefuehrtVorher = (await anwendungsfaelle.quellen()).find((q) => quelleSchluessel(q) === key);
+            const inventar = gefuehrtVorher === undefined ? undefined : await anwendungsfaelle.quelleAufraeumInventar(genannt);
+            const meldeVergessen = (gefuehrt, zahl) => {
+                console.log(`Quelle ${quelleAlsText(gefuehrt)} vergessen, Checkouts und Links bleiben liegen.`);
+                if (zahl === 0)
+                    console.log('  Kein Link betroffen.');
+                else {
+                    console.log(`  ${zahl === 1 ? '1 Link gilt' : `${zahl} Links gelten`} jetzt als „Link ohne bekannte Quelle", das Aktualisieren prüft ${zahl === 1 ? 'ihn' : 'sie'} nicht mehr.`);
+                    console.log(`  source add derselben Quelle macht ${zahl === 1 ? 'ihn wieder zu einem normalen Link' : 'sie wieder zu normalen Links'}.`);
+                }
+            };
+            // Leeres Inventar (F31a): nichts zum Aufräumen, keine Rückfrage, sofort vergessen wie bisher.
+            if (gefuehrtVorher === undefined ||
+                inventar === undefined ||
+                (inventar.links.length === 0 && inventar.checkouts.length === 0)) {
+                const gefuehrt = await anwendungsfaelle.quelleEntfernen(genannt);
+                meldeVergessen(gefuehrt, inventar?.links.length ?? 0);
+                return 0;
+            }
+            // Aufräum-Rückfrage VOR dem Vergessen (F31a): ein Ja mit lokalen Änderungen darf weder löschen
+            // noch die Quelle vergessen, das entscheidet erst quelleAufraeumen unten.
+            const teile = [
+                zahlwort(inventar.links.length, 'Link', 'Links'),
+                zahlwort(inventar.checkouts.length, 'Checkout', 'Checkouts'),
+            ];
+            const bleibt = (n) => (n === 1 ? ', bleibt liegen' : ', bleiben liegen');
+            if (inventar.plugins.length > 0)
+                teile.push(zahlwort(inventar.plugins.length, 'installiertes Plugin', 'installierte Plugins') + bleibt(inventar.plugins.length));
+            if (inventar.zeigerPfade.length > 0)
+                teile.push(zahlwort(inventar.zeigerPfade.length, 'Zeiger-Eintrag', 'Zeiger-Einträge') + bleibt(inventar.zeigerPfade.length));
+            let frage = `Skills von ${quelleAlsText(gefuehrtVorher)} komplett vom Rechner löschen (${teile.join(', ')})?`;
+            if (inventar.checkoutsMitLokalenAenderungen.length > 0) {
+                const anzahl = inventar.checkoutsMitLokalenAenderungen.length;
+                frage +=
+                    `\n${anzahl === 1 ? 'Achtung: 1 Checkout hat' : `Achtung: ${anzahl} Checkouts haben`} lokale Änderungen. ` +
+                        'Ein Ja bricht dann ab, ohne zu löschen, die Quelle bleibt bekannt. Erst committen/pushen oder verwerfen, dann erneut versuchen.';
+            }
+            if (!(await ports.rueckfrage.bestaetigen(frage))) {
+                const gefuehrt = await anwendungsfaelle.quelleEntfernen(genannt);
+                meldeVergessen(gefuehrt, inventar.links.length);
+                return 0;
+            }
+            // Ja: erst aufräumen (wirft bei lokalen Änderungen, VOR jeder Löschung, F31a), erst danach die
+            // Quelle vergessen, damit ein Abbruch sie unberührt lässt.
+            const ergebnis = await anwendungsfaelle.quelleAufraeumen(inventar);
+            const gefuehrt = await anwendungsfaelle.quelleEntfernen(genannt);
+            console.log(`Quelle ${quelleAlsText(gefuehrt)} entfernt und aufgeräumt.`);
+            console.log(`  entfernt      ${zahlwort(ergebnis.entfernteLinks, 'Link', 'Links')}, ${zahlwort(ergebnis.entfernteCheckouts, 'Checkout', 'Checkouts')}.`);
+            if (inventar.plugins.length > 0)
+                console.log(`  installierte Plugins bleiben liegen: ${inventar.plugins.join(', ')}`);
+            if (inventar.zeigerPfade.length > 0)
+                console.log(`  Zeiger-Einträge bleiben liegen: ${inventar.zeigerPfade.join(', ')}`);
+            return 0;
+        }
+        if (unterkommando === 'rename') {
+            const text = rest[1];
+            const name = rest[2];
+            if (text === undefined || name === undefined || name.trim().length === 0)
+                throw new Error('source rename braucht eine URL oder einen Pfad und einen neuen Namen, etwa hmgr source rename https://example.com/skills.git skills');
+            const genannt = quelleAusText(text);
+            const umbenannt = await anwendungsfaelle.quelleUmbenennen(genannt, name);
+            console.log(`Quelle ${quelleAlsText(umbenannt)} heißt jetzt „${quelleName(umbenannt)}".`);
+            return 0;
+        }
         if (unterkommando === 'list') {
             const zustand = await ports.zustand.lesen();
             if (zustand.quellen.length === 0)
                 console.log('Keine Quellen.');
             for (const quelle of zustand.quellen)
-                console.log(`${quelle.art}  ${quelleAlsText(quelle)}`);
+                console.log(`${quelle.art}  ${quelleName(quelle)}  ${quelleAlsText(quelle)}`);
             return 0;
         }
-        throw new Error(`${unterkommando === undefined ? 'source braucht ein Unterkommando' : `Unbekanntes Unterkommando „${unterkommando}" für source`}: source add <url|pfad> oder source list. hmgr help source zeigt Beispiele.`);
+        throw new Error(`${unterkommando === undefined ? 'source braucht ein Unterkommando' : `Unbekanntes Unterkommando „${unterkommando}" für source`}: source add <url|pfad>, source rename <url|pfad> <name>, source remove <url|pfad> oder source list. hmgr help source zeigt Beispiele.`);
     }
     if (kommando === 'dir') {
         const schalter = schalterLesen(argv.slice(1), 'dir');
@@ -269,8 +375,10 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
                 await anwendungsfaelle.arbeitsverzeichnisHinzufuegen(ziel.ort.pfad, composer);
         }
         if (kommando === 'unlink') {
-            await anwendungsfaelle.linkEntfernen({ skill, ziel, lokal });
+            const ergebnis = await anwendungsfaelle.linkEntfernen({ skill, ziel, lokal });
             console.log(`Link ${skill} entfernt.`);
+            if (ergebnis.hinweis !== undefined)
+                console.log(ergebnis.hinweis);
             return 0;
         }
         const quelle = werte.get('quelle');
@@ -327,6 +435,8 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
         }
         const quellenText = neueQuellen === 1 ? '1 neue Quelle' : `${neueQuellen} neue Quellen`;
         console.log(`${uebernommen} übernommen, ${uebersprungen} übersprungen, ${quellenText}.`);
+        if (ergebnis.hinweis !== undefined)
+            console.log(ergebnis.hinweis);
         return 0;
     }
     if (kommando === 'plugin') {
@@ -380,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');
@@ -409,8 +577,10 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
                 console.log(`  aktualisiert    ${kopf}  ${aktualisierung.von.slice(0, 8)} -> ${aktualisierung.nach.slice(0, 8)}`);
             else if (aktualisierung.ergebnis === 'unveraendert')
                 console.log(`  unverändert     ${kopf}`);
-            else
+            else if (aktualisierung.ergebnis === 'uebersprungen')
                 console.log(`  übersprungen    ${kopf}  lokale Änderung (E15)`);
+            else
+                console.log(`  fehlgeschlagen  ${kopf}  ${aktualisierung.fehler}`);
         }
         for (const name of pluginHarnesses)
             console.log(`  Plugins         ${name} aktualisiert (E14)`);
@@ -440,12 +610,12 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
                 if (eintrag.art === 'fremd')
                     console.log(`  ${eintrag.name}  fremd`);
                 else if (eintrag.art === 'link-ohne-quelle')
-                    console.log(`  ${eintrag.name}  Link ohne bekannte Quelle (${eintrag.checkoutPfad})`);
+                    console.log(`  ${eintrag.name}  Link ohne bekannte Quelle (${eintrag.checkoutPfad})${beschreibeGrund(zielZustand.gruende.get(eintrag.name))}`);
                 else {
                     // Steht im Zeiger eine Versionseinschränkung, kommt sie vor den aufgelösten Ref (E33).
                     const einschraenkung = zielZustand.einschraenkungen.get(eintrag.link.name);
                     const spanne = einschraenkung === undefined ? '' : `${einschraenkung} → `;
-                    console.log(`  ${eintrag.link.name}  ${spanne}${quelleAlsText(eintrag.link.checkout.quelle)} @ ${eintrag.link.checkout.ref} (${eintrag.link.skill.pfad})`);
+                    console.log(`  ${eintrag.link.name}  ${spanne}${quelleAlsText(eintrag.link.checkout.quelle)} @ ${eintrag.link.checkout.ref} (${eintrag.link.skill.pfad})${beschreibeGrund(zielZustand.gruende.get(eintrag.link.name))}`);
                 }
             }
             if (zielZustand.plugins !== undefined)
@@ -456,8 +626,132 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
             console.log(`Nicht vorhanden: ${fehlend.join(', ')}`);
         return 0;
     }
+    if (kommando === 'harness') {
+        const schalter = schalterLesen(argv.slice(1), 'harness');
+        unterkommandoPruefen('harness', schalter);
+        const { rest, werte } = schalter;
+        const unterkommando = rest[0];
+        if (unterkommando === 'skills-dir') {
+            const harnessName = rest[1];
+            if (harnessName === undefined)
+                throw new Error('harness skills-dir braucht einen Harness-Namen, etwa hmgr harness skills-dir hermes. ' +
+                    'hmgr harness list zeigt die bekannten Namen.');
+            const unter = rest[2];
+            const profilName = werte.get('profil');
+            const ort = profilName === undefined ? { art: 'home' } : { art: 'profil', name: profilName };
+            const ziel = { harness: harnessName, ort };
+            const ortText = beschreibeOrt(ort);
+            if (unter === undefined) {
+                restPruefen(rest, 2, 'harness', 'skills-dir');
+                const pfad = await anwendungsfaelle.verwalteterSkillOrdner(ziel);
+                if (pfad === undefined) {
+                    console.log(`${harnessName} ${ortText}: kein Skill-Ordner verwaltet.`);
+                    console.log(`  Festlegen mit hmgr harness skills-dir ${harnessName} add <pfad>.`);
+                }
+                else {
+                    console.log(`${harnessName} ${ortText}  ${pfad}`);
+                }
+                return 0;
+            }
+            if (unter === 'add') {
+                restPruefen(rest, 4, 'harness', 'skills-dir');
+                const pfad = rest[3];
+                if (pfad === undefined)
+                    throw new Error('harness skills-dir <name> add braucht einen Pfad, etwa ' +
+                        'hmgr harness skills-dir hermes add ~/.hermes/external-skills.');
+                const gesetzt = await anwendungsfaelle.skillOrdnerFestlegen(ziel, pfad);
+                console.log(`${harnessName} ${ortText} liest Skills jetzt aus ${gesetzt}.`);
+                return 0;
+            }
+            if (unter === 'remove') {
+                restPruefen(rest, 3, 'harness', 'skills-dir');
+                const ergebnis = await anwendungsfaelle.skillOrdnerEntfernen(ziel);
+                console.log(`${harnessName} ${ortText}: Eintrag für ${ergebnis.pfad} entfernt.`);
+                const inhalt = `${zahlwort(ergebnis.hmgrLinks, 'hmgr-Link', 'hmgr-Links')}, ${zahlwort(ergebnis.fremdeEintraege, 'fremder Eintrag', 'fremde Einträge')}`;
+                const frage = `Ordner ${ergebnis.pfad} enthält noch ${inhalt}. Löschen?`;
+                if (await ports.rueckfrage.bestaetigen(frage)) {
+                    await anwendungsfaelle.skillOrdnerLoeschen(ziel, ergebnis.pfad);
+                    console.log(`  Ordner ${ergebnis.pfad} gelöscht.`);
+                }
+                return 0;
+            }
+            throw new Error(`Unbekanntes Unterkommando „${unter}" für harness skills-dir: harness skills-dir <name>, ` +
+                'harness skills-dir <name> add <pfad> oder harness skills-dir <name> remove. ' +
+                'hmgr help harness zeigt Beispiele.');
+        }
+        if (unterkommando === 'list') {
+            const aktive = new Set(await anwendungsfaelle.aktiveHarnesses());
+            const fehlend = new Set(await anwendungsfaelle.nichtVorhandeneHarnesses());
+            for (const name of anwendungsfaelle.harnessTypen()) {
+                const aktivText = aktive.has(name) ? 'aktiv' : 'inaktiv';
+                const vorhandenText = fehlend.has(name) ? 'nicht vorhanden' : 'vorhanden';
+                console.log(`${name}  ${aktivText}, ${vorhandenText}`);
+            }
+            return 0;
+        }
+        if (unterkommando === 'enable' || unterkommando === 'disable') {
+            const name = rest[1];
+            if (name === undefined)
+                throw new Error(`harness ${unterkommando} braucht einen Harness-Namen. hmgr harness list zeigt die bekannten Harness-Typen.`);
+            const vorherAktiv = new Set(await anwendungsfaelle.aktiveHarnesses());
+            if (unterkommando === 'enable') {
+                await anwendungsfaelle.harnessAktivieren(name);
+                console.log(vorherAktiv.has(name) ? `${name} ist schon aktiv.` : `${name} aktiviert.`);
+                return 0;
+            }
+            await anwendungsfaelle.harnessDeaktivieren(name);
+            console.log(vorherAktiv.has(name) ? `${name} deaktiviert.` : `${name} ist schon inaktiv.`);
+            // Säubern-Angebot nur, wenn eigene Konfiguration liegt, mit derselben Bedingung wie die GUI
+            // (E38, GRILL.md Entwurfskritik 4): eigene Links oder eine liegen gebliebene Registrierung
+            // ohne Link (E38 R7), sonst machten CLI und GUI verschiedene Angebote.
+            const ziele = (await anwendungsfaelle.istZustand()).filter((z) => z.ziel.harness === name &&
+                (z.eintraege.some((eintrag) => eintrag.art !== 'fremd') || z.istRegistriert));
+            if (ziele.length === 0)
+                return 0;
+            const links = ziele.reduce((n, z) => n + z.eintraege.filter((eintrag) => eintrag.art !== 'fremd').length, 0);
+            const eintraege = ziele.filter((z) => z.istRegistriert).length;
+            // Wer den harness-eigenen Eintrag angelegt hat, weiß niemand (E38 R7), also wird er benannt,
+            // nicht hmgr zugeschrieben. Gleicher Text wie bilanzText in der GUI.
+            const teile = [
+                links === 0
+                    ? zahlwort(ziele.length, 'leeres Ziel', 'leere Ziele')
+                    : `${zahlwort(links, 'Link', 'Links')} in ${zahlwort(ziele.length, 'Ziel', 'Zielen')}`,
+            ];
+            if (eintraege > 0)
+                teile.push(zahlwort(eintraege, 'harness-eigener Eintrag', 'harness-eigene Einträge'));
+            const liste = ziele.map((z) => `  ${z.verzeichnis}`).join('\n');
+            const frage = `Es liegt noch Konfiguration (${teile.join(', ')}):\n${liste}\nEntfernen?`;
+            if (!(await ports.rueckfrage.bestaetigen(frage))) {
+                console.log('  Konfiguration bleibt liegen, hmgr pflegt sie nicht mehr.');
+                return 0;
+            }
+            const ergebnis = await anwendungsfaelle.saeubern(name);
+            for (const zielErgebnis of ergebnis.ziele) {
+                if (zielErgebnis.entfernteLinks.length > 0)
+                    console.log(`  entfernt      ${beschreibeOrt(zielErgebnis.ziel.ort)}  ${zielErgebnis.entfernteLinks.join(', ')}`);
+                if (zielErgebnis.konfigurationZurueckgebaut)
+                    console.log(`  zurückgebaut  ${beschreibeOrt(zielErgebnis.ziel.ort)}  harness-eigene Konfiguration`);
+            }
+            return 0;
+        }
+        throw new Error(`${unterkommando === undefined ? 'harness braucht ein Unterkommando' : `Unbekanntes Unterkommando „${unterkommando}" für harness`}: harness list, harness enable <name> oder harness disable <name>. hmgr help harness zeigt Beispiele.`);
+    }
     throw new Error(`Unbekanntes Kommando „${kommando}". hmgr --help zeigt alle Kommandos.`);
 }
+/** Grund eines Links als Suffix (E37). „manuell" bleibt stumm, damit die Ausgabe ruhig bleibt. */
+function beschreibeGrund(grund) {
+    if (grund === undefined || grund.art === 'manuell')
+        return '';
+    return grund.art === 'plugin' ? `  Plugin „${grund.plugin}"` : '  über Zeiger';
+}
+/** Zahl mit passender Endung, Singular oder Plural, für die Säubern-Frage bei harness disable (E38). */
+function zahlwort(n, ein, viele) {
+    return `${n} ${n === 1 ? ein : viele}`;
+}
+/** Text auf `laenge` Zeichen kappen, mit „…" markiert, damit eine Skill-Liste lesbar bleibt (E39). */
+function kappen(text, laenge = 80) {
+    return text.length <= laenge ? text : `${text.slice(0, laenge - 1)}…`;
+}
 function beschreibeOrt(ort) {
     if (ort.art === 'home')
         return 'home';
@@ -467,16 +761,35 @@ function beschreibeOrt(ort) {
 }
 function istModellFehler(fehler) {
     return (fehler instanceof NameBelegt ||
+        fehler instanceof LinkAnlegenFehlgeschlagen ||
         fehler instanceof SkillMehrdeutig ||
         fehler instanceof SkillUnbekannt ||
         fehler instanceof OrtNichtUnterstuetzt ||
         fehler instanceof ZeigerMehrdeutig ||
+        fehler instanceof ZeigerSchreibenGesperrt ||
         fehler instanceof HarnessNichtVorhanden ||
+        fehler instanceof HarnessTypUnbekannt ||
         fehler instanceof KeinPassenderRef ||
         fehler instanceof EinschraenkungOhneZeiger ||
         fehler instanceof PluginMehrdeutig ||
         fehler instanceof PluginUnbekannt ||
-        fehler instanceof AbhaengigkeitFehlt);
+        fehler instanceof AbhaengigkeitFehlt ||
+        fehler instanceof QuelleUnbekannt ||
+        fehler instanceof QuelleNameBelegt ||
+        fehler instanceof QuelleAufraeumenLokaleAenderungen ||
+        fehler instanceof SkillOrdnerFaehigkeitFehlt ||
+        fehler instanceof SkillOrdnerBereitsVerwaltet ||
+        fehler instanceof SkillOrdnerNichtVerwaltet ||
+        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
@@ -501,9 +814,38 @@ function naechsterSchritt(fehler) {
         return 'Der Harness legt sein Verzeichnis beim ersten Start an. hmgr status zeigt, welche Harnesses hier liegen.';
     if (fehler instanceof OrtNichtUnterstuetzt)
         return 'profil:<name> kennt nur hermes, claude-code und agents kennen home und dir:<pfad>.';
-    const text = fehler instanceof Error ? fehler.message : '';
-    if (text.startsWith('Unbekannter Harness'))
-        return 'Bekannt sind claude-code, hermes und agents.';
+    if (fehler instanceof HarnessTypUnbekannt)
+        return 'Bekannt sind claude-code, hermes und agents. hmgr harness list zeigt sie mit ihrem Stand.';
+    if (fehler instanceof QuelleUnbekannt)
+        return 'hmgr source list zeigt die bekannten Quellen.';
+    if (fehler instanceof QuelleNameBelegt)
+        return 'hmgr source list zeigt die schon vergebenen Namen.';
+    if (fehler instanceof ZeigerSchreibenGesperrt)
+        return 'Nutze --local, das schreibt nichts in den Zeiger.';
+    if (fehler instanceof SkillOrdnerFaehigkeitFehlt)
+        return 'Nur hermes kennt einen verwalteten Skill-Ordner.';
+    if (fehler instanceof SkillOrdnerBereitsVerwaltet)
+        return `Erst entfernen: hmgr harness skills-dir ${fehler.ziel.harness} remove${fehler.ziel.ort.art === 'profil' ? ` --profil ${fehler.ziel.ort.name}` : ''}.`;
+    if (fehler instanceof SkillOrdnerNichtVerwaltet)
+        return `Festlegen mit hmgr harness skills-dir ${fehler.ziel.harness} add <pfad>${fehler.ziel.ort.art === 'profil' ? ` --profil ${fehler.ziel.ort.name}` : ''}.`;
+    if (fehler instanceof SkillOrdnerUngueltig)
+        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();
+        },
+    };
+}