hmgr 0.0.4 → 0.0.6

package/dist/adapter/git.js

@@ -1,12 +1,10 @@
 // Git über die CLI, keine Bibliothek. Checkout-Schema und Worktrees nach E22, Discovery nach E11.
-import { execFile, spawn } from 'node:child_process';
+import { spawn } from 'node:child_process';
 import { readFile, readdir, mkdir, realpath, rm, stat } from 'node:fs/promises';
 import path from 'node:path';
-import { promisify } from 'node:util';
 import { marketplaceLesen } from "./marketplace-json.js";
-import { SKILL_DATEI, skillAusPfad } from "./skill-md.js";
+import { SKILL_DATEI, skillAusPfad, skillName } from "./skill-md.js";
 import { BASIS_NAME, basisPfad, quelleZerlegen, refDekodieren, worktreePfad } from "./checkout-pfad.js";
-const ausfuehren = promisify(execFile);
 /** Bekannte Orte für Skills, in dieser Reihenfolge (E11). */
 export const BEKANNTE_ORTE = ['skills', '.claude/skills', '.agents/skills'];
 /** Eine lokale Arbeitskopie hat für hmgr keinen Ref, es zählt der Stand auf der Platte (B11). */
@@ -30,13 +28,17 @@ async function existiert(pfad) {
 }
 /**
  * Aus Dateipfaden die Skill-Verzeichnisse bilden: ein Verzeichnis mit SKILL.md ist ein Skill.
- * Bekannte Orte zuerst (E11). Den Namen bekommt der Skill erst aus seiner SKILL.md (E32).
+ * Bekannte Orte zuerst (E11). Den Namen bekommt der Skill erst aus seiner SKILL.md (E32). Eine
+ * SKILL.md direkt an der Wurzel (`teile.length === 1`) ergibt den Pfad `''`: das Repo ist selbst
+ * ein Skill (E11-Nachtrag 2026-09-05). `''` ist die einzige interne Schreibweise dafür, nie `.` —
+ * `checkoutZerlegen`, `skillAusPfad` und die Sparse-Checkout-Muster (unten) sind darauf abgestimmt.
+ * Wurzel-Skill und `skills/`-Unterordner schließen sich nicht aus, beide landen in der Liste.
  */
 export function skillPfadeAusDateien(dateien) {
     const verzeichnisse = new Set();
     for (const datei of dateien) {
         const teile = datei.split('/');
-        if (teile.at(-1) !== SKILL_DATEI || teile.length < 2)
+        if (teile.at(-1) !== SKILL_DATEI)
             continue;
         verzeichnisse.add(teile.slice(0, -1).join('/'));
     }
@@ -96,6 +98,14 @@ async function inhalteAufPlatte(wurzel, pfade) {
     }
     return ergebnis;
 }
+/**
+ * Ersatzname für einen Skill, dessen Pfad kein Segment hergibt (Wurzel-Skill, E11-Nachtrag): der
+ * Repo-Name der Quelle. Ohne ihn hieße der Skill „" und ein Link auf ihn zeigte nicht auf einen
+ * Eintrag im Ziel, sondern auf das Zielverzeichnis (E32).
+ */
+function ersatznameDerQuelle(quelle) {
+    return quelle.art === 'lokal' ? path.basename(quelle.pfad) : quelleZerlegen(quelle).repo;
+}
 async function dateienAufPlatte(wurzel, unter = '') {
     const eintraege = await readdir(path.join(wurzel, unter), { withFileTypes: true }).catch(() => []);
     const dateien = [];
@@ -115,14 +125,37 @@ export class GitQuellen {
     constructor(wurzel) {
         this.wurzel = wurzel;
     }
+    /**
+     * stdin ist zu und git darf nicht nach Zugangsdaten fragen, sonst hängt ein wartender Aufruf
+     * den ganzen Ablauf (dasselbe Muster wie beim claude-Ausführer). Der Timeout ist großzügiger
+     * als dort, ein erster Clone über ein langsames Netz braucht Zeit.
+     */
     async git(args, cwd) {
-        const { stdout } = await ausfuehren('git', args, { cwd, maxBuffer: 32 * 1024 * 1024 });
-        return stdout;
+        return await new Promise((erfuellen, ablehnen) => {
+            const kind = spawn('git', args, {
+                cwd,
+                stdio: ['ignore', 'pipe', 'pipe'],
+                timeout: 300_000,
+                killSignal: 'SIGKILL',
+                env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+            });
+            const stuecke = [];
+            const fehler = [];
+            kind.stdout.on('data', (teil) => stuecke.push(teil));
+            kind.stderr.on('data', (teil) => fehler.push(teil));
+            kind.on('error', ablehnen);
+            kind.on('close', (code) => {
+                if (code === 0)
+                    erfuellen(Buffer.concat(stuecke).toString('utf8'));
+                else
+                    ablehnen(new Error(`git ${args.join(' ')}: ${Buffer.concat(fehler).toString('utf8').trim()}`));
+            });
+        });
     }
     /** Wie `git`, aber mit Text auf stdin und Bytes als Ergebnis: `execFile` kennt keine Eingabe. */
     async gitMitEingabe(args, cwd, eingabe) {
         return await new Promise((erfuellen, ablehnen) => {
-            const kind = spawn('git', args, { cwd });
+            const kind = spawn('git', args, { cwd, timeout: 300_000, killSignal: 'SIGKILL' });
             const stuecke = [];
             const fehler = [];
             kind.stdout.on('data', (teil) => stuecke.push(teil));
@@ -159,24 +192,32 @@ export class GitQuellen {
     async skillMdInhalte(basis, ref, pfade) {
         if (pfade.length === 0)
             return new Map();
-        const eingabe = `${pfade.map((p) => `${ref}:${p}/${SKILL_DATEI}`).join('\n')}\n`;
+        // Ein Wurzel-Skill hat den Pfad `''`: `${ref}:${p}/${SKILL_DATEI}` ergäbe `ref:/SKILL.md` mit
+        // führendem Schrägstrich, den git als eigenen (ungültigen) Pfad läse statt als Wurzel (E39).
+        const eingabe = `${pfade.map((p) => `${ref}:${p.length === 0 ? SKILL_DATEI : `${p}/${SKILL_DATEI}`}`).join('\n')}\n`;
         const ausgabe = await this.gitMitEingabe(['cat-file', '--batch'], basis, eingabe).catch(() => undefined);
         if (ausgabe === undefined)
             return new Map();
         return batchInhalte(ausgabe, pfade);
     }
-    /** Skills der Quelle, Namen aus dem Frontmatter der SKILL.md (E32). */
+    /**
+     * Skills der Quelle, Namen aus dem Frontmatter der SKILL.md (E32). Ein Wurzel-Skill (Pfad `''`,
+     * E11-Nachtrag) hat keinen Verzeichnisnamen, aus dem `skillAusPfad` einen Namen ableiten könnte:
+     * der Repo-Name ist der Ersatzname, nie der leere String, sonst zeigte ein Link ohne Frontmatter
+     * `name` auf einen Eintrag mit leerem Namen im Ziel (E32).
+     */
     async skills(quelle, ref) {
+        const ersatzname = ersatznameDerQuelle(quelle);
         if (quelle.art === 'lokal') {
             const pfade = skillPfadeAusDateien(await dateienAufPlatte(quelle.pfad));
             const inhalte = await inhalteAufPlatte(quelle.pfad, pfade);
-            return pfade.map((pfad) => skillAusPfad(pfad, inhalte.get(pfad)));
+            return pfade.map((pfad) => skillAusPfad(pfad, inhalte.get(pfad), ersatzname));
         }
         const basis = await this.basis(quelle);
         const ausgabe = await this.git(['ls-tree', '-r', '--name-only', ref], basis);
         const pfade = skillPfadeAusDateien(ausgabe.split('\n').filter((z) => z.length > 0));
         const inhalte = await this.skillMdInhalte(basis, ref, pfade);
-        return pfade.map((pfad) => skillAusPfad(pfad, inhalte.get(pfad)));
+        return pfade.map((pfad) => skillAusPfad(pfad, inhalte.get(pfad), ersatzname));
     }
     /**
      * Marketplace einer Quelle (E24). Der Inhalt kommt aus dem Git-Baum, nicht aus einem Checkout:
@@ -206,7 +247,9 @@ export class GitQuellen {
             plugins: gelesen.plugins.map((p) => ({
                 name: p.name,
                 dependencies: p.dependencies,
-                skills: p.skills.map((pfad) => skillAusPfad(pfad, inhalte.get(pfad))),
+                // Auch hier kann ein Pfad leer sein (`"source": "."` mit `"skills": ["."]`): derselbe
+                // Ersatzname wie im Katalog, damit nie ein Skill ohne Namen entsteht (E32).
+                skills: p.skills.map((pfad) => skillAusPfad(pfad, inhalte.get(pfad), ersatznameDerQuelle(quelle))),
             })),
         };
     }
@@ -265,8 +308,14 @@ export class GitQuellen {
         for (const eintrag of vorhanden)
             if (!WURZEL_MUSTER.includes(eintrag))
                 muster.add(eintrag);
+        // Ein Wurzel-Skill (E48 a, leerer Pfad) ist der ganze Baum: `/**` nimmt ihn nach `!/*/` wieder
+        // rekursiv auf, ein Muster `//` wäre kein gültiges Sparse-Checkout-Muster. Der Link, den
+        // `linkLegen` darauf setzt, zeigt dann auf die Worktree-Wurzel selbst (E11-Nachtrag 2026-09-05):
+        // die ganze Arbeitskopie samt `.git` wird sichtbar, nicht nur die SKILL.md und ihre
+        // Unterordner. Ein Harness liest ohnehin nur SKILL.md und referenzierte Unterordner, das `.git`
+        // stört nicht — wohl aber sähe ein Nutzer, der den Link im Finder öffnet, den vollen Worktree.
         for (const skill of skills)
-            muster.add(`/${skill.pfad}/`);
+            muster.add(skill.pfad === '' ? '/**' : `/${skill.pfad}/`);
         await this.git(['sparse-checkout', 'set', '--no-cone', '--', ...muster], pfad);
         if (neu)
             await this.git(['checkout', '--detach', ref], pfad);
@@ -300,6 +349,12 @@ export class GitQuellen {
                 }
         return ergebnis;
     }
+    /**
+     * Scheitert der Abruf der Quelle, etwa ohne Netz (E51), ergibt es `fehlgeschlagen` mit
+     * Fehlertext statt eines geworfenen Fehlers: `aktualisieren` (Kern) ruft das je Checkout auf,
+     * ein einzelner Fehlschlag darf die übrigen Checkouts nicht abbrechen. Gefangen wird genau der
+     * Abruf und nichts sonst, damit kein Programmierfehler als Fehlschlag der Quelle erscheint.
+     */
     async aktualisieren(checkout) {
         if (checkout.quelle.art === 'lokal')
             return { ergebnis: 'unveraendert' };
@@ -307,7 +362,12 @@ export class GitQuellen {
             return { ergebnis: 'uebersprungen', grund: 'lokale-aenderung' }; // E15
         const basis = await this.basis(checkout.quelle);
         const von = (await this.git(['rev-parse', 'HEAD'], checkout.pfad)).trim();
-        await this.git(['fetch', '--prune', '--tags', 'origin'], basis);
+        try {
+            await this.git(['fetch', '--prune', '--tags', 'origin'], basis);
+        }
+        catch (fehler) {
+            return { ergebnis: 'fehlgeschlagen', fehler: fehler instanceof Error ? fehler.message : String(fehler) };
+        }
         const nach = (await this.git(['rev-parse', checkout.ref], basis)).trim();
         if (von === nach)
             return { ergebnis: 'unveraendert' };
@@ -357,10 +417,62 @@ export class GitQuellen {
             relativerPfad: path.relative(wurzel, echt).split(path.sep).join('/'),
         };
     }
+    /**
+     * `--no-optional-locks`, weil die Prüfung auch fremde Arbeitskopien trifft (E48 a): ohne den
+     * Schalter schreibt `status` deren Index-Cache neu, und die Erhebung wäre nicht mehr rein lesend.
+     */
     async lokaleAenderungen(checkout) {
         if (checkout.quelle.art === 'lokal')
             return false;
-        const ausgabe = await this.git(['status', '--porcelain'], checkout.pfad);
+        const ausgabe = await this.git(['--no-optional-locks', 'status', '--porcelain'], checkout.pfad);
         return ausgabe.trim().length > 0;
     }
+    /**
+     * Enthaltensein ohne Netzzugriff (E48): `merge-base --is-ancestor` gegen den lokalen Stand des
+     * Tracking-Refs, kein `fetch`. Schlägt der Aufruf fehl, etwa ohne Tracking-Ref, gilt „nicht
+     * enthalten" als sicherer Standard.
+     */
+    async imRemoteEnthalten(pfad, ref) {
+        try {
+            await this.git(['merge-base', '--is-ancestor', 'HEAD', `refs/remotes/origin/${ref}`], pfad);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async wurzelSkill(pfad) {
+        const inhalt = await readFile(path.join(pfad, SKILL_DATEI), 'utf8').catch(() => undefined);
+        if (inhalt === undefined)
+            return null;
+        // Der Skill-Pfad ist leer, der Verzeichnisname ist deshalb der Ordner der Arbeitskopie selbst
+        // (E32). Aus dem leeren Pfad allein käme ein leerer Name, und ein leerer Name zeigte im Ziel
+        // auf das Zielverzeichnis statt auf einen Eintrag darin.
+        const { beschreibung } = skillAusPfad('', inhalt);
+        const name = skillName(path.basename(pfad), inhalt);
+        return beschreibung === undefined ? { name, pfad: '' } : { name, pfad: '', beschreibung };
+    }
+    /**
+     * Gitignorierte Dateien einer Arbeitskopie, für die Vorschau vor dem Ersetzen (E50). Wie bei
+     * `lokaleAenderungen`: `--no-optional-locks`, damit das Lesen auch einer fremden Arbeitskopie
+     * nichts auf der Platte verändert. Kein Git-Repo oder ein Git-Fehler ergibt eine leere Liste.
+     */
+    async gitignorierteDateien(pfad) {
+        try {
+            // Nur die Arbeitskopie selbst zählt. Liegt der Ordner bloß in einem umgebenden Repo, meldete
+            // `status` dessen ignorierte Dateien, die mit dem Ordner nichts zu tun haben, und die
+            // Vorschau behauptete einen Verlust, den das Ersetzen gar nicht anrichtet.
+            const wurzel = await this.git(['--no-optional-locks', 'rev-parse', '--show-toplevel'], pfad);
+            if ((await realpath(wurzel.trim())) !== (await realpath(pfad)))
+                return [];
+            const ausgabe = await this.git(['--no-optional-locks', 'status', '--porcelain', '--ignored'], pfad);
+            return ausgabe
+                .split('\n')
+                .filter((zeile) => zeile.startsWith('!! '))
+                .map((zeile) => zeile.slice(3));
+        }
+        catch {
+            return [];
+        }
+    }
 }

package/dist/adapter/hermes.js

@@ -1,11 +1,12 @@
 // Hermes Agent: Grundverhalten plus Profile entdecken und Verzeichnis in der config.yaml registrieren.
 // Skills landen nie in <hermes-home>/skills, sondern in einem Ordner aus skills.external_dirs (E13).
 import { readFileSync, realpathSync } from 'node:fs';
-import { mkdir, readFile, readdir, stat, writeFile } from 'node:fs/promises';
+import { mkdir, readFile, readdir, rm, stat, writeFile } from 'node:fs/promises';
 import path from 'node:path';
-import { Document, isSeq, parseDocument } from 'yaml';
-import { OrtNichtUnterstuetzt } from "../kern/modell.js";
+import { Document, isMap, isScalar, isSeq, parseDocument } from 'yaml';
+import { McpAbweichenderEintrag, OrtNichtUnterstuetzt, SkillOrdnerUngueltig, } from "../kern/modell.js";
 import { gitignoreEintragen, istGitRepo } from "./gitignore.js";
+import { tiefGleich } from "./vergleich.js";
 const HERMES_VERZEICHNIS = '.hermes';
 const PROFILE_VERZEICHNIS = 'profiles';
 const CONFIG = 'config.yaml';
@@ -46,9 +47,39 @@ function trustedProjectDirs(daten) {
         return [];
     return dirs.filter((d) => typeof d === 'string');
 }
+/** Liest mcp_servers aus einer geparsten config.yaml (E61). Fehlt der Abschnitt, ist er leer. */
+function mcpServers(daten) {
+    if (typeof daten !== 'object' || daten === null)
+        return {};
+    const mcp = daten['mcp_servers'];
+    if (typeof mcp !== 'object' || mcp === null || Array.isArray(mcp))
+        return {};
+    return mcp;
+}
+/** Der neutrale Konfigblock als reines Objekt, für die config.yaml und für den Vergleich (E61). */
+function mcpKonfigAlsObjekt(konfig) {
+    if ('command' in konfig)
+        return {
+            command: konfig.command,
+            ...(konfig.args === undefined ? {} : { args: konfig.args }),
+            ...(konfig.env === undefined ? {} : { env: konfig.env }),
+        };
+    return { url: konfig.url, ...(konfig.headers === undefined ? {} : { headers: konfig.headers }) };
+}
 export class Hermes {
     name = 'hermes';
     home;
+    /**
+     * MCP-Server (E61): nur Home und Profil, denn Hermes kennt keine Projektebene für MCPs. Bindung
+     * über Arrow-Funktionen auf `this`, damit die Fähigkeit ohne eigene Klasse auskommt.
+     */
+    mcp = {
+        ebenen: () => ['home', 'profil'],
+        einhaengen: async (mcpName, konfig, ort) => this.mcpEinhaengen(ort, mcpName, konfig),
+        aushaengen: async (mcpName, ort) => this.mcpAushaengen(ort, mcpName),
+        eingehaengte: async (ort) => this.mcpEingehaengte(ort),
+        envDatei: (ort) => path.join(this.mcpHermesHome(ort), '.env'),
+    };
     /** `home` ist das HOME des Nutzers, das Hermes-Home liegt darunter als `.hermes`. */
     constructor(home) {
         this.home = home;
@@ -96,10 +127,12 @@ export class Hermes {
         }
         return parseDocument(text).toJS();
     }
-    zielVerzeichnis(ort) {
-        if (ort.art === 'arbeitsverzeichnis')
-            return path.join(ort.pfad, HERMES_VERZEICHNIS, EIGENER_ORDNER);
-        const hermesHome = this.hermesHome(ort);
+    /**
+     * Der eine von hmgr verwaltete `external_dirs`-Eintrag (E13, E56): der erste unterhalb des
+     * Hermes-Home, ohne Hermes' eigenen Ordner `skills`. Alle weiteren Einträge der config.yaml
+     * ignoriert hmgr vollständig. `undefined` heißt: kein solcher Eintrag steht dort.
+     */
+    ersterEintrag(hermesHome) {
         const eigenerOrdner = path.join(hermesHome, EIGENER_ORDNER);
         for (const eintrag of externalDirs(this.gelesen(hermesHome))) {
             const pfad = this.aufloesen(eintrag, hermesHome);
@@ -109,7 +142,98 @@ export class Hermes {
                 continue;
             return pfad;
         }
-        return path.join(hermesHome, STANDARD_ORDNER);
+        return undefined;
+    }
+    zielVerzeichnis(ort) {
+        if (ort.art === 'arbeitsverzeichnis')
+            return path.join(ort.pfad, HERMES_VERZEICHNIS, EIGENER_ORDNER);
+        const hermesHome = this.hermesHome(ort);
+        return this.ersterEintrag(hermesHome) ?? path.join(hermesHome, STANDARD_ORDNER);
+    }
+    /**
+     * Orte mit einem verwalteten Skill-Ordner (E56): Home und Profil, beides ein vollständiges
+     * Hermes-Home mit config.yaml. Ein Arbeitsverzeichnis hat keine, dort steht `.hermes/skills`
+     * fest (E13).
+     */
+    skillOrdnerOrte() {
+        return ['home', 'profil'];
+    }
+    /**
+     * Fähigkeit: verwalteter Skill-Ordner (E56). Anders als `zielVerzeichnis` ohne Ausweichen auf den
+     * Standard-Ordner: `undefined` heißt wirklich „kein Eintrag verwaltet". Arbeitsverzeichnis kennt
+     * die Fähigkeit nicht, dort steht `.hermes/skills` fest (E13).
+     */
+    async verwalteterSkillOrdner(ort) {
+        if (ort.art === 'arbeitsverzeichnis')
+            return undefined;
+        return this.ersterEintrag(this.hermesHome(ort));
+    }
+    /**
+     * Prüft einen genannten Pfad als verwalteten Skill-Ordner (E56) und gibt ihn aufgelöst zurück:
+     * `~` und relative Angaben deutet er wie Hermes selbst (relativ zum Hermes-Home). Er muss
+     * unterhalb des Hermes-Home liegen und darf nicht Hermes' eigener Ordner `skills` sein, sonst
+     * `SkillOrdnerUngueltig`. Beides wird zusätzlich am echten Pfad gemessen, damit ein Symlink im Weg
+     * nicht aus dem Hermes-Home herausführt; geliefert wird trotzdem der ungefolgte Pfad, denn so
+     * steht er auch in der config.yaml.
+     */
+    gepruefterOrdner(hermesHome, pfad) {
+        const ordner = this.aufloesen(pfad, hermesHome);
+        // Variablen löst hmgr nicht auf (siehe `aufloesen`): ein solcher Pfad ist kein Ort auf der Platte.
+        if (ordner === undefined)
+            throw new SkillOrdnerUngueltig(pfad, 'ausserhalb');
+        // Nur die Elternkette wird aufgelöst: ist der Ordner selbst ein Symlink, gilt er als das, was er
+        // ist, und ein Löschen träfe später den Symlink, nicht sein Ziel.
+        const echt = path.join(this.echterPfad(path.dirname(ordner)), path.basename(ordner));
+        const basis = this.echterPfad(hermesHome);
+        if (!unterhalb(ordner, hermesHome) || !unterhalb(echt, basis))
+            throw new SkillOrdnerUngueltig(ordner, 'ausserhalb');
+        for (const [kandidat, wurzel] of [
+            [ordner, path.join(hermesHome, EIGENER_ORDNER)],
+            [echt, path.join(basis, EIGENER_ORDNER)],
+        ])
+            if (kandidat === wurzel || unterhalb(kandidat, wurzel))
+                throw new SkillOrdnerUngueltig(ordner, 'eigener-ordner');
+        return ordner;
+    }
+    /**
+     * Fähigkeit: Skill-Ordner festlegen (E56). Nur unterhalb des Hermes-Home und außerhalb des
+     * eigenen Ordners `skills`, sonst `SkillOrdnerUngueltig`. Legt den Ordner an und trägt ihn ein,
+     * wie `vorbereiten`/`registrieren` es für den Standard-Ordner schon tun. Gibt den aufgelösten
+     * Pfad zurück, wie er in der config.yaml landet.
+     */
+    async skillOrdnerFestlegen(ort, pfad) {
+        if (ort.art === 'arbeitsverzeichnis')
+            throw new OrtNichtUnterstuetzt(this.name, ort.art);
+        const hermesHome = this.hermesHome(ort);
+        const ordner = this.gepruefterOrdner(hermesHome, pfad);
+        await mkdir(ordner, { recursive: true });
+        await this.registrieren(hermesHome, ordner);
+        return ordner;
+    }
+    /**
+     * Fähigkeit: Skill-Ordner entfernen (E56), Gegenstück zu `skillOrdnerFestlegen`: nur der
+     * `external_dirs`-Eintrag verschwindet aus der config.yaml, der Ordner selbst bleibt unangetastet
+     * (dafür `skillOrdnerLoeschen`).
+     */
+    async skillOrdnerEntfernen(ort) {
+        if (ort.art === 'arbeitsverzeichnis')
+            throw new OrtNichtUnterstuetzt(this.name, ort.art);
+        const hermesHome = this.hermesHome(ort);
+        const pfad = this.ersterEintrag(hermesHome);
+        if (pfad === undefined)
+            return;
+        await this.deregistrieren(hermesHome, pfad);
+    }
+    /**
+     * Fähigkeit: den (zuvor verwalteten) Ordner mit Inhalt löschen (E56). Sicherheitsnetz: dieselbe
+     * Prüfung wie beim Festlegen, egal was der Aufrufer meint — nur unterhalb des Hermes-Home, nie
+     * Hermes' eigener Ordner `skills`, kein Ausbruch über einen Symlink im Weg.
+     */
+    async skillOrdnerLoeschen(ort, pfad) {
+        if (ort.art === 'arbeitsverzeichnis')
+            throw new OrtNichtUnterstuetzt(this.name, ort.art);
+        const ordner = this.gepruefterOrdner(this.hermesHome(ort), pfad);
+        await rm(ordner, { recursive: true, force: true });
     }
     async vorbereiten(ort) {
         const verzeichnis = this.zielVerzeichnis(ort);
@@ -132,16 +256,76 @@ export class Hermes {
             return;
         const eintrag = this.alsEintrag(verzeichnis);
         const liste = doc.getIn(['skills', 'external_dirs']);
+        const skills = doc.get('skills');
         if (isSeq(liste))
             liste.add(eintrag);
-        else
+        // `skills:` ohne Inhalt ist ein Skalar (null), kein Abschnitt: `setIn` bräche daran ab
+        // („Expected YAML collection at skills"). Ein Abschnitt mit Inhalt bekommt nur den neuen
+        // Schlüssel, alles daneben bleibt stehen.
+        else if (skills === null || skills === undefined)
+            doc.set('skills', { external_dirs: [eintrag] });
+        else if (isMap(skills))
             doc.setIn(['skills', 'external_dirs'], [eintrag]);
+        // Steht unter `skills` etwas anderes als ein Abschnitt, hat es jemand von Hand so gemeint:
+        // überschreiben hieße Daten wegwerfen, also rührt hmgr die Datei nicht an.
+        else
+            throw new Error(`In ${pfad} ist „skills" kein Abschnitt, hmgr trägt dort nichts ein.`);
         await mkdir(hermesHome, { recursive: true });
         await writeFile(pfad, doc.toString());
     }
     folgtLinks() {
         return true;
     }
+    /**
+     * Fähigkeit Zurückbauen (E38), Gegenstück zu `registrieren`: entfernt den `external_dirs`-Eintrag,
+     * den hmgr für diesen Ort eingetragen hat, falls einer da ist. Arbeitsverzeichnisse kennen keinen
+     * solchen Eintrag, dort steht `.hermes/skills` fest (E13).
+     */
+    async zurueckbauen(ort) {
+        if (ort.art === 'arbeitsverzeichnis')
+            return false;
+        const hermesHome = this.hermesHome(ort);
+        return await this.deregistrieren(hermesHome, this.zielVerzeichnis(ort));
+    }
+    /**
+     * Fähigkeit „ist registriert" (E38 R7), Gegenstück zu `vorbereiten`/`zurueckbauen`, ohne etwas zu
+     * ändern: ob der `external_dirs`-Eintrag für diesen Ort noch in der config.yaml steht, unabhängig
+     * davon, ob dort noch Links liegen. Arbeitsverzeichnisse kennen keinen solchen Eintrag (E13),
+     * dort steht `.hermes/skills` fest, wie bei `zurueckbauen`.
+     */
+    async istRegistriert(ort) {
+        if (ort.art === 'arbeitsverzeichnis')
+            return false;
+        const hermesHome = this.hermesHome(ort);
+        const verzeichnis = this.zielVerzeichnis(ort);
+        return externalDirs(this.gelesen(hermesHome)).some((eintrag) => this.aufloesen(eintrag, hermesHome) === verzeichnis);
+    }
+    /** Entfernt jeden Eintrag aus skills.external_dirs, der auf `verzeichnis` zeigt. Kommentare bleiben. */
+    async deregistrieren(hermesHome, verzeichnis) {
+        const pfad = path.join(hermesHome, CONFIG);
+        const text = await readFile(pfad, 'utf8').catch(() => undefined);
+        if (text === undefined)
+            return false;
+        const doc = parseDocument(text);
+        const liste = doc.getIn(['skills', 'external_dirs']);
+        if (!isSeq(liste))
+            return false;
+        let geaendert = false;
+        for (let i = liste.items.length - 1; i >= 0; i--) {
+            const item = liste.items[i];
+            const wert = typeof item === 'string' ? item : isScalar(item) ? item.value : undefined;
+            if (typeof wert !== 'string')
+                continue;
+            if (this.aufloesen(wert, hermesHome) !== verzeichnis)
+                continue;
+            liste.delete(i);
+            geaendert = true;
+        }
+        if (!geaendert)
+            return false;
+        await writeFile(pfad, doc.toString());
+        return true;
+    }
     /** Vergleich wie bei Hermes über den aufgelösten Pfad, Symlinks eingeschlossen. */
     echterPfad(pfad) {
         try {
@@ -178,7 +362,7 @@ export class Hermes {
         return {
             hinweis: `Hermes lädt Projekt-Skills in ${wurzel} erst nach \`hermes skills trust ${wurzel}\`.`,
             abhilfe: {
-                frage: `Hermes lädt Projekt-Skills in ${wurzel} erst nach Vertrauen. Jetzt als vertrauenswürdig eintragen? [j/N]`,
+                frage: `Hermes lädt Projekt-Skills in ${wurzel} erst nach Vertrauen. Jetzt als vertrauenswürdig eintragen?`,
                 erledigt: `${wurzel} als vertrauenswürdig in Hermes eingetragen.`,
                 ausfuehren: async () => await this.vertrauen(wurzel),
             },
@@ -205,6 +389,47 @@ export class Hermes {
         await mkdir(hermesHome, { recursive: true });
         await writeFile(pfad, doc.toString());
     }
+    /** Home oder Profil als Hermes-Home (E61): mcp kennt nur diese beiden Orte. */
+    mcpHermesHome(ort) {
+        if (ort.art !== 'home' && ort.art !== 'profil')
+            throw new OrtNichtUnterstuetzt(this.name, ort.art);
+        return this.hermesHome(ort);
+    }
+    async mcpEingehaengte(ort) {
+        return Object.keys(mcpServers(this.gelesen(this.mcpHermesHome(ort))));
+    }
+    /**
+     * Trägt `mcp_servers.<name>` ein (E61). Steht dort schon ein Eintrag, der vom Katalogblock
+     * abweicht (egal, wer ihn gelegt hat), bricht es ab, ohne stillschweigend zu überschreiben; ein
+     * gleicher Eintrag ist idempotent. Kommentare bleiben erhalten.
+     */
+    async mcpEinhaengen(ort, mcpName, konfig) {
+        const hermesHome = this.mcpHermesHome(ort);
+        const pfad = path.join(hermesHome, CONFIG);
+        const text = await readFile(pfad, 'utf8').catch(() => undefined);
+        const doc = text === undefined ? new Document({}) : parseDocument(text);
+        const bestehend = mcpServers(doc.toJS())[mcpName];
+        const wert = mcpKonfigAlsObjekt(konfig);
+        if (bestehend !== undefined && !tiefGleich(bestehend, wert))
+            throw new McpAbweichenderEintrag({ harness: this.name, ort }, mcpName);
+        doc.setIn(['mcp_servers', mcpName], wert);
+        await mkdir(hermesHome, { recursive: true });
+        await writeFile(pfad, doc.toString());
+    }
+    /** Entfernt genau diesen Eintrag aus mcp_servers (E61). Kommentare bleiben erhalten. */
+    async mcpAushaengen(ort, mcpName) {
+        const hermesHome = this.mcpHermesHome(ort);
+        const pfad = path.join(hermesHome, CONFIG);
+        const text = await readFile(pfad, 'utf8').catch(() => undefined);
+        if (text === undefined)
+            return;
+        const doc = parseDocument(text);
+        const mcp = doc.get('mcp_servers');
+        if (!isMap(mcp) || !mcp.has(mcpName))
+            return;
+        mcp.delete(mcpName);
+        await writeFile(pfad, doc.toString());
+    }
     /** Fähigkeit Profile entdecken: Verzeichnisse mit config.yaml, bei jedem Aufruf frisch gelesen (E19). */
     async profile() {
         const basis = path.join(this.home, HERMES_VERZEICHNIS, PROFILE_VERZEICHNIS);

package/dist/adapter/marketplace-json.js

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