hmgr 0.0.3 → 0.0.5

package/dist/cli/main.js

@@ -5,7 +5,7 @@ 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, 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";
@@ -18,7 +18,12 @@ 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,16 +34,62 @@ 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(),
     };
     return { anwendungsfaelle: new Anwendungsfaelle(ports), ports };
 }
-/** Schalter ohne Wert. Alles andere braucht einen. `help` steht hier, damit --help nie greift. */
-const FLAGGEN = new Set(['ersetzen', 'local', 'lokal', 'probelauf', 'help']);
+/**
+ * Was jedes Kommando auswertet, gleichlautend mit seiner Hilfe. Alles andere bricht ab. `--help`
+ * steht nirgends, weil der Hilfe-Dispatch vor jedem schalterLesen läuft.
+ */
+const SCHALTER = {
+    source: { werte: ['name'], flaggen: [] },
+    dir: { werte: ['composer'], flaggen: [] },
+    link: {
+        werte: ['harness', 'ort', 'composer', 'quelle', 'version'],
+        flaggen: ['local', 'lokal', 'ersetzen'],
+    },
+    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'] },
+    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
+ * `schalter` bleibt es bei der Familienliste, das reicht, solange alle Unterkommandos dieselben
+ * Schalter lesen.
+ */
+const UNTERKOMMANDOS = {
+    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: [] },
+        list: { woerter: 1, schalter: [] },
+    },
+    plugin: {
+        add: { woerter: 2, schalter: ['harness', 'ort', 'composer', 'quelle', 'local', 'lokal'] },
+        remove: { woerter: 2, schalter: ['harness', 'ort', 'composer', 'local', 'lokal'] },
+        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];
     const rest = [];
     const werte = new Map();
     const flaggen = new Set();
@@ -49,18 +100,50 @@ function schalterLesen(args, kommando) {
             continue;
         }
         const name = arg.slice(2);
-        if (FLAGGEN.has(name)) {
+        if (erlaubt.flaggen.includes(name)) {
             flaggen.add(name);
             continue;
         }
+        if (!erlaubt.werte.includes(name))
+            throw new Error(`Unbekannter Schalter --${name} für ${kommando}. hmgr help ${kommando} zeigt die Schalter.`);
         const wert = args[++i];
         if (wert === undefined)
             throw new Error(`Schalter --${name} braucht einen Wert, etwa --${name} <wert>. ` +
-                `${kommando === undefined ? 'hmgr --help' : `hmgr help ${kommando}`} zeigt die Schalter.`);
+                `hmgr help ${kommando} zeigt die Schalter.`);
         werte.set(name, wert);
     }
     return { rest, werte, flaggen };
 }
+/** Ein Wort mehr, als das Kommando liest, ist ein Tippfehler und kein stiller Zusatz. */
+function restPruefen(rest, woerter, kommando, unterkommando) {
+    const zuviel = rest[woerter];
+    if (zuviel === undefined)
+        return;
+    const verwendung = unterkommando === undefined ? kommando : `${kommando} ${unterkommando}`;
+    // Der Name des Unterkommandos zählt zu den Wörtern, aber nicht zu den Argumenten.
+    const argumente = woerter - (unterkommando === undefined ? 0 : 1);
+    throw new Error(`${verwendung} erwartet ${argumente === 0 ? 'kein' : 'kein weiteres'} Argument „${zuviel}". ` +
+        `hmgr help ${kommando} zeigt die Verwendung.`);
+}
+/**
+ * Prüft, was erst mit dem Unterkommando feststeht: liest es die gesetzten Schalter, und steht ein
+ * Wort zu viel da. Ein unbekanntes Unterkommando meldet die Familie selbst.
+ */
+function unterkommandoPruefen(kommando, schalter) {
+    const unterkommando = schalter.rest[0];
+    if (unterkommando === undefined)
+        return;
+    const menge = UNTERKOMMANDOS[kommando][unterkommando];
+    if (menge === undefined)
+        return;
+    const erlaubt = menge.schalter;
+    if (erlaubt !== undefined)
+        for (const name of [...schalter.werte.keys(), ...schalter.flaggen])
+            if (!erlaubt.includes(name))
+                throw new Error(`Unbekannter Schalter --${name} für ${kommando} ${unterkommando}. ` +
+                    `hmgr help ${kommando} zeigt die Schalter.`);
+    restPruefen(schalter.rest, menge.woerter, kommando, unterkommando);
+}
 function ortLesen(text) {
     const roh = text ?? 'home';
     if (roh === 'home')
@@ -78,6 +161,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);
@@ -107,16 +192,26 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
         return 0;
     }
     if (kommando === 'source') {
-        const unterkommando = argv[1];
+        const schalter = schalterLesen(argv.slice(1), 'source');
+        unterkommandoPruefen('source', schalter);
+        const { rest, werte } = schalter;
+        const unterkommando = rest[0];
         if (unterkommando === 'add') {
-            const text = argv[2];
+            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 quelle = quelleAusText(text);
-            const { skills, marketplace } = await anwendungsfaelle.quelleHinzufuegen(quelle);
-            console.log(`Quelle ${quelleAlsText(quelle)} (${quelle.art}), ${skills.length} Skills:`);
-            for (const skill of skills)
-                console.log(`  ${skill.name}  ${skill.pfad}`);
+            const genannt = quelleAusText(text);
+            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}) als „${quelleName(quelle)}", ${skills.length} 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) {
@@ -126,18 +221,94 @@ 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 { rest, werte } = schalterLesen(argv.slice(1), 'dir');
+        const schalter = schalterLesen(argv.slice(1), 'dir');
+        unterkommandoPruefen('dir', schalter);
+        const { rest, werte } = schalter;
         const unterkommando = rest[0];
         if (unterkommando === 'add') {
             const pfad = rest[1];
@@ -176,6 +347,7 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
     }
     if (kommando === 'link' || kommando === 'unlink') {
         const { rest, werte, flaggen } = schalterLesen(argv.slice(1), kommando);
+        restPruefen(rest, 1, kommando);
         const skill = rest[0];
         if (skill === undefined)
             throw new Error(`${kommando} braucht einen Skill-Namen, etwa hmgr ${kommando} <skill>. ` +
@@ -191,8 +363,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');
@@ -213,6 +387,7 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
     }
     if (kommando === 'adopt') {
         const { rest, werte, flaggen } = schalterLesen(argv.slice(1), 'adopt');
+        restPruefen(rest, 1, 'adopt');
         const ziel = { harness: werte.get('harness') ?? 'claude-code', ort: ortLesen(werte.get('ort')) };
         const probelauf = flaggen.has('probelauf');
         const name = rest[0];
@@ -248,10 +423,14 @@ 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') {
-        const { rest, werte, flaggen } = schalterLesen(argv.slice(1), 'plugin');
+        const schalter = schalterLesen(argv.slice(1), 'plugin');
+        unterkommandoPruefen('plugin', schalter);
+        const { rest, werte, flaggen } = schalter;
         const unterkommando = rest[0];
         if (unterkommando === 'list') {
             const marketplaces = await anwendungsfaelle.marketplaces();
@@ -301,6 +480,7 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
     }
     if (kommando === 'sync') {
         const { rest } = schalterLesen(argv.slice(1), 'sync');
+        restPruefen(rest, 1, 'sync');
         const ergebnis = await anwendungsfaelle.abgleich(rest[0]);
         if (ergebnis.zeigerPfad !== undefined)
             console.log(`Zeiger ${ergebnis.zeigerPfad}`);
@@ -317,7 +497,8 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
         return 0;
     }
     if (kommando === 'update') {
-        const { checkouts: liste, pluginHarnesses } = await anwendungsfaelle.aktualisieren();
+        restPruefen(schalterLesen(argv.slice(1), 'update').rest, 0, 'update');
+        const { checkouts: liste, pluginHarnesses, aufraeumen } = await anwendungsfaelle.aktualisieren();
         if (liste.length === 0)
             console.log('Keine Checkouts.');
         for (const { checkout, aktualisierung } of liste) {
@@ -326,14 +507,31 @@ 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)`);
+        // Zum Schluss die verwaisten Checkouts: was gelöscht wurde und was liegen bleibt.
+        for (const verwaist of aufraeumen.verwaiste) {
+            const kopf = `${quelleAlsText(verwaist.checkout.quelle)} @ ${verwaist.checkout.ref}`;
+            if (verwaist.geloescht)
+                console.log(`  gelöscht        ${kopf}  verwaist (${verwaist.checkout.pfad})`);
+            else if (verwaist.lokaleAenderung)
+                console.log(`  liegen lassen   ${kopf}  verwaist, aber lokale Änderung (E15)`);
+            else
+                console.log(`  liegen lassen   ${kopf}  verwaist, ohne Bestätigung nicht gelöscht`);
+        }
+        if (aufraeumen.verwaiste.length > 0) {
+            const geloescht = aufraeumen.verwaiste.filter((v) => v.geloescht).length;
+            console.log(`${aufraeumen.verwaiste.length} verwaist, ${geloescht} gelöscht, ${aufraeumen.verwaiste.length - geloescht} liegen geblieben.`);
+        }
         return 0;
     }
     if (kommando === 'status') {
+        restPruefen(schalterLesen(argv.slice(1), 'status').rest, 0, 'status');
         for (const zielZustand of await anwendungsfaelle.istZustand()) {
             console.log(`Ziel ${zielZustand.ziel.harness} ${beschreibeOrt(zielZustand.ziel.ort)} (${zielZustand.verzeichnis})`);
             if (zielZustand.eintraege.length === 0)
@@ -342,12 +540,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)
@@ -358,8 +556,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';
@@ -373,12 +695,21 @@ function istModellFehler(fehler) {
         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);
 }
 /**
  * Der nächste Schritt zu einem Fehler aus dem Kern. Die Fehlertexte selbst bleiben, wie das Modell
@@ -398,14 +729,29 @@ function naechsterSchritt(fehler) {
     if (fehler instanceof AbhaengigkeitFehlt)
         return 'Die Abhängigkeit steht in keinem Plugin desselben Marketplace, das kann nur die Quelle beheben.';
     if (fehler instanceof KeinPassenderRef)
-        return 'hmgr update holt neue Tags der Quelle. Sonst einen vorhandenen Tag- oder Branchnamen als --version nennen.';
+        return 'Die Tags der Quelle sind frisch geholt, keiner passt. Sonst einen vorhandenen Tag- oder Branchnamen als --version nennen.';
     if (fehler instanceof HarnessNichtVorhanden)
         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.';
     return undefined;
 }
 export async function main(argv, umgebung) {