hmgr 0.0.4 → 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,7 +34,7 @@ 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(),
@@ -41,7 +46,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'],
@@ -53,6 +58,7 @@ const SCHALTER = {
     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 +66,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 +82,11 @@ const UNTERKOMMANDOS = {
         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];
@@ -145,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);
@@ -176,22 +194,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:`);
+            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 +221,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 +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');
@@ -327,6 +423,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') {
@@ -409,8 +507,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 +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)
@@ -456,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';
@@ -471,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
@@ -501,9 +734,24 @@ 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.';
     return undefined;
 }
 export async function main(argv, umgebung) {

package/dist/gui/icons.js

@@ -0,0 +1,114 @@
+// Quellen-Icon im Main-Prozess (E60): Besitzer-Avatar bei GitHub/Gitea, sonst Favicon, sonst
+// generisch. Lädt nur hier (nie im Renderer, contextIsolation lässt dort ohnehin kein fetch mit
+// Netzzugriff zu, das hier ist reine Main-Prozess-Politik), cached als data-URL auf Platte
+// unterhalb von HMGR_HOME (Aufrufer reicht das Verzeichnis rein), damit Tests und der Smoke-Test
+// nie ein echtes Verzeichnis anfassen. Ein Fehlschlag wird mitgecacht, aber nur für einen Tag: ein
+// Treffer gilt für immer, ein Fehlschlag verfällt, sonst bliebe es bei generischen Symbolen für
+// jeden, der beim ersten Start ohne Netz war. „lokal" und jede unbekannte Adresse ergeben sofort null.
+import { createHash } from 'node:crypto';
+import { mkdir, readFile, stat, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { urlOrt } from "../kern/quelle-ort.js";
+const STANDARD_TIMEOUT_MS = 5000;
+/**
+ * Ein Fehlschlag hält einen Tag, ein Treffer hält für immer. Ohne Verfall bekäme jeder, der beim
+ * ersten Start offline war, dauerhaft nur generische Symbole — der Cache soll das Netz schonen,
+ * nicht ein einmaliges „gerade kein Netz" festschreiben.
+ */
+const FEHLSCHLAG_HALTBARKEIT_MS = 24 * 60 * 60 * 1000;
+/**
+ * Obergrenze für ein Icon. Ein Avatar oder Favicon ist ein paar Kilobyte groß; alles darüber ist
+ * kein Symbol mehr und hätte als data-URL nichts im Cache und in der Ansicht verloren.
+ */
+const MAX_ICON_BYTES = 512 * 1024;
+/**
+ * Kandidaten-URLs für den Besitzer-Avatar, in Versuchsreihenfolge (F35): GitHub liefert den Avatar
+ * über einen eigenen Pfad, jeder andere http(s)-Host bekommt zuerst den mutmaßlichen Avatar-Pfad
+ * versucht (das bedient auch Gitea), dann sein Favicon.
+ */
+export function iconKandidaten(ort) {
+    if (ort.host === 'github.com')
+        return [`https://github.com/${ort.besitzer}.png?size=40`];
+    return [`https://${ort.host}/${ort.besitzer}.png`, `https://${ort.host}/favicon.ico`];
+}
+function cacheDateiname(schluessel) {
+    return `${createHash('sha256').update(schluessel).digest('hex')}.txt`;
+}
+/**
+ * Die Zeitüberschreitung umfasst auch das Lesen des Rumpfs, nicht nur den Kopf: ein Server, der die
+ * Kopfzeilen sofort schickt und dann tröpfelt, würde den Aufruf sonst unbegrenzt hängen lassen.
+ * Deshalb läuft die ganze Arbeit unter demselben Signal, der Wecker fällt erst danach.
+ */
+async function mitTimeout(arbeit, timeoutMs) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await arbeit(controller.signal);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+async function alsDataUrl(antwort) {
+    if (!antwort.ok)
+        return undefined;
+    const typ = antwort.headers.get('content-type') ?? '';
+    if (!typ.startsWith('image/'))
+        return undefined;
+    const angekuendigt = Number(antwort.headers.get('content-length'));
+    if (Number.isFinite(angekuendigt) && angekuendigt > MAX_ICON_BYTES)
+        return undefined;
+    const puffer = Buffer.from(await antwort.arrayBuffer());
+    if (puffer.length === 0 || puffer.length > MAX_ICON_BYTES)
+        return undefined;
+    return `data:${typ.split(';')[0]};base64,${puffer.toString('base64')}`;
+}
+/**
+ * Was im Cache steht: eine data-URL (Treffer, gilt immer), oder ein Fehlschlag (leere Datei), der
+ * nur bis zu seiner Haltbarkeit gilt. Fehlt beides, muss abgefragt werden.
+ */
+async function ausCache(cachePfad) {
+    const inhalt = await readFile(cachePfad, 'utf8').catch(() => undefined);
+    if (inhalt === undefined)
+        return undefined;
+    if (inhalt.length > 0)
+        return { wert: inhalt };
+    const info = await stat(cachePfad).catch(() => undefined);
+    if (info && Date.now() - info.mtimeMs < FEHLSCHLAG_HALTBARKEIT_MS)
+        return { wert: null };
+    return undefined;
+}
+/**
+ * Icon einer Quelle als data-URL, oder null (lokale Quelle, unlesbare Adresse oder jeder
+ * Fehlschlag: Zeitüberschreitung, Netzfehler, kein Bild). Das Ergebnis – auch ein Fehlschlag –
+ * landet auf Platte, ein zweiter Aufruf für denselben Host/Besitzer fragt nicht erneut ab; ein
+ * gecachter Fehlschlag verfällt nach einem Tag und wird dann erneut versucht.
+ */
+export async function iconFuerQuelle(quelle, optionen) {
+    if (quelle.art === 'lokal')
+        return null;
+    const ort = urlOrt(quelle.url);
+    if (!ort || ort.host === 'local')
+        return null;
+    const holen = optionen.fetch ?? ((url, init) => fetch(url, init));
+    const timeoutMs = optionen.timeoutMs ?? STANDARD_TIMEOUT_MS;
+    const schluessel = `${ort.host}/${ort.besitzer}`;
+    const cachePfad = path.join(optionen.cacheVerzeichnis, cacheDateiname(schluessel));
+    const cached = await ausCache(cachePfad);
+    if (cached !== undefined)
+        return cached.wert;
+    let ergebnis;
+    for (const url of iconKandidaten(ort)) {
+        try {
+            ergebnis = await mitTimeout(async (signal) => alsDataUrl(await holen(url, { signal })), timeoutMs);
+        }
+        catch {
+            ergebnis = undefined;
+        }
+        if (ergebnis)
+            break;
+    }
+    await mkdir(optionen.cacheVerzeichnis, { recursive: true }).catch(() => undefined);
+    await writeFile(cachePfad, ergebnis ?? '', 'utf8').catch(() => undefined);
+    return ergebnis ?? null;
+}