hmgr 0.0.4 → 0.0.5

package/dist/adapter/claude-code.js

@@ -1,26 +1,30 @@
 // Claude Code: Grundverhalten plus Plugins über die claude-CLI (E16, E24, E27).
-import { execFile } from 'node:child_process';
+import { spawn } from 'node:child_process';
 import { mkdir, stat } from 'node:fs/promises';
 import path from 'node:path';
-import { promisify } from 'node:util';
 import { OrtNichtUnterstuetzt, pluginSchluessel } from "../kern/modell.js";
 import { gitignoreEintragen, istGitRepo } from "./gitignore.js";
 const GITIGNORE_ZEILE = '.claude/';
-const ausfuehrenRoh = promisify(execFile);
-/** Standard-Ausführer: `claude` vom PATH. Ein Fehlschlag wird zum Code, nicht zur Ausnahme. */
-export const claudeAusfuehrer = async (args, cwd) => {
-    try {
-        const { stdout } = await ausfuehrenRoh('claude', args, {
-            ...(cwd === undefined ? {} : { cwd }),
-            maxBuffer: 32 * 1024 * 1024,
-        });
-        return { stdout, code: 0 };
-    }
-    catch (fehler) {
-        const f = fehler;
-        return { stdout: `${f.stdout ?? ''}${f.stderr ?? ''}`, code: typeof f.code === 'number' ? f.code : 1 };
-    }
-};
+/**
+ * Standard-Ausführer: `claude` vom PATH. Ein Fehlschlag wird zum Code, nicht zur Ausnahme.
+ * stdin ist zu, sonst hängt eine CLI, die auf Eingabe wartet, den ganzen Ablauf; der Timeout
+ * fängt alles Übrige (beobachtet: 13 Minuten ohne Rückkehr in der GUI). SIGKILL, weil die
+ * CLI SIGTERM überleben kann.
+ */
+export const claudeAusfuehrer = (args, cwd) => new Promise((aufloesen) => {
+    const kind = spawn('claude', args, {
+        ...(cwd === undefined ? {} : { cwd }),
+        stdio: ['ignore', 'pipe', 'pipe'],
+        timeout: 120_000,
+        killSignal: 'SIGKILL',
+    });
+    let stdout = '';
+    let stderr = '';
+    kind.stdout.on('data', (d) => (stdout += d));
+    kind.stderr.on('data', (d) => (stderr += d));
+    kind.on('error', (fehler) => aufloesen({ stdout: fehler.message, code: 1 }));
+    kind.on('close', (code) => aufloesen({ stdout: code === 0 ? stdout : `${stdout}${stderr}`, code: code ?? 1 }));
+});
 export class PluginListeUnbekannteForm extends Error {
     constructor(text) {
         super(`claude plugin list --json: ${text}`);

package/dist/adapter/dateisystem.js

@@ -1,16 +1,33 @@
 // Ziele im Dateisystem: Links legen, lesen und entfernen. Fremde Einträge bleiben unangetastet (E12).
+import { createHash } from 'node:crypto';
 import { lstat, mkdir, readFile, readdir, readlink, rm, stat, symlink, unlink } from 'node:fs/promises';
 import path from 'node:path';
 import { NameBelegt } from "../kern/modell.js";
 import { checkoutZerlegen, quelleZerlegen } from "./checkout-pfad.js";
 import { LOKAL_REF } from "./git.js";
-import { SKILL_DATEI, skillName } from "./skill-md.js";
+import { SKILL_DATEI, skillAusPfad } from "./skill-md.js";
+/** Dateien eines Ordners rekursiv, `.git` und `node_modules` ausgenommen, Symlinks nicht gefolgt. */
+async function ordnerDateien(wurzel, unter, ergebnis) {
+    const eintraege = await readdir(path.join(wurzel, unter), { withFileTypes: true }).catch(() => []);
+    for (const eintrag of eintraege) {
+        if (eintrag.name === '.git' || eintrag.name === 'node_modules')
+            continue;
+        const rel = unter ? `${unter}/${eintrag.name}` : eintrag.name;
+        if (eintrag.isDirectory())
+            await ordnerDateien(wurzel, rel, ergebnis);
+        else if (eintrag.isFile())
+            ergebnis.push({ relativerPfad: rel, inhalt: await readFile(path.join(wurzel, rel)) });
+    }
+}
 export class DateisystemZiele {
     wurzel;
     zustand;
-    constructor(wurzel, zustand) {
+    /** $XDG_STATE_HOME, falls gesetzt und nicht leer, für den vorrangigen Lockfile-Ort (E50). */
+    xdgStateHome;
+    constructor(wurzel, zustand, xdgStateHome) {
         this.wurzel = wurzel;
         this.zustand = zustand;
+        this.xdgStateHome = xdgStateHome;
     }
     async quellen() {
         return (await this.zustand.lesen()).quellen;
@@ -18,12 +35,14 @@ export class DateisystemZiele {
     /**
      * Der Skill hinter einem Linkziel. Der Name kommt aus der SKILL.md am Linkziel, nicht aus dem
      * Namen des Eintrags im Ziel: derselbe Skill soll überall gleich heißen, auch wenn ein Eintrag
-     * von Hand umbenannt wurde (E32).
+     * von Hand umbenannt wurde (E32). Über `skillAusPfad` kommt zugleich die Beschreibung (E39) und
+     * die übrigen Frontmatter-Felder (E55) mit, die die Ziel-Tabellen der GUI zeigen (E60) — vorher
+     * fehlten sie hier, weil nur der Name gelesen wurde. Ein Aufruf, ein Lesen, ein Parsen des
+     * Frontmatters: bei vielen Links summiert sich jedes zweite Parsen derselben Datei.
      */
     async skill(zielPfad, skillPfad, ersatz) {
-        const verzeichnisname = skillPfad.split('/').filter((t) => t.length > 0).at(-1) ?? ersatz;
         const inhalt = await readFile(path.join(zielPfad, SKILL_DATEI), 'utf8').catch(() => undefined);
-        return { name: skillName(verzeichnisname, inhalt), pfad: skillPfad };
+        return skillAusPfad(skillPfad, inhalt, ersatz);
     }
     /** Liest aus dem Linkziel Quelle, Ref und Skill zurück. Undefined heißt: kein eigener Link. */
     async deuten(zielPfad) {
@@ -101,6 +120,10 @@ export class DateisystemZiele {
         return ergebnis;
     }
     async linkLegen(ziel, verzeichnis, name, checkout, skill, ersetzen) {
+        // Ein leerer Name oder einer mit Pfadtrenner ergäbe keinen Eintrag im Ziel, sondern einen Pfad:
+        // `path.join` fiele auf das Zielverzeichnis selbst zurück, und `ersetzen` löschte es (E12, E32).
+        if (name.length === 0 || name.includes('/') || name.includes(path.sep))
+            throw new Error(`Ungültiger Name für einen Link: „${name}"`);
         await mkdir(verzeichnis, { recursive: true });
         const pfad = path.join(verzeichnis, name);
         const info = await lstat(pfad).catch(() => undefined);
@@ -123,4 +146,81 @@ export class DateisystemZiele {
         if (await this.deuten(zielPfad))
             await unlink(path.join(verzeichnis, name));
     }
+    /**
+     * Löscht einen fremden Eintrag von der Platte (E46): ein Symlink wird als Link entfernt, ohne
+     * ihm zu folgen, die Arbeitskopie dahinter bleibt unangetastet; ein Verzeichnis wird rekursiv
+     * gelöscht. Ob der Eintrag tatsächlich fremd ist, hat der Kern schon geprüft.
+     */
+    async eintragLoeschen(_ziel, verzeichnis, name) {
+        const pfad = path.join(verzeichnis, name);
+        const info = await lstat(pfad).catch(() => undefined);
+        if (info === undefined)
+            return;
+        if (info.isSymbolicLink())
+            await unlink(pfad);
+        else
+            await rm(pfad, { recursive: true, force: true });
+    }
+    /**
+     * Lockfile-Kandidaten in Suchreihenfolge (E50): zuerst $XDG_STATE_HOME/skills/.skill-lock.json,
+     * nur wenn die Variable gesetzt und nicht leer ist, sonst wie bisher neben `skillsVerzeichnis`.
+     */
+    lockPfadKandidaten(skillsVerzeichnis) {
+        const kandidaten = [];
+        if (this.xdgStateHome !== undefined && this.xdgStateHome.length > 0)
+            kandidaten.push(path.join(this.xdgStateHome, 'skills', '.skill-lock.json'));
+        kandidaten.push(path.join(path.dirname(skillsVerzeichnis), '.skill-lock.json'));
+        return kandidaten;
+    }
+    /** Eintrag zu `name` aus dem Lockfile-Inhalt. Kaputtes JSON oder fehlende Felder: undefined. */
+    lockEintragAusInhalt(roh, name) {
+        try {
+            const geparst = JSON.parse(roh);
+            const eintrag = geparst.skills?.[name];
+            if (eintrag === undefined)
+                return undefined;
+            const sourceUrl = eintrag.sourceUrl;
+            const skillFolderHash = eintrag.skillFolderHash;
+            if (typeof sourceUrl !== 'string' || typeof skillFolderHash !== 'string')
+                return undefined;
+            const ref = eintrag.ref;
+            const skillPath = eintrag.skillPath;
+            return {
+                sourceUrl,
+                skillFolderHash,
+                ...(typeof ref === 'string' ? { ref } : {}),
+                ...(typeof skillPath === 'string' ? { skillPath } : {}),
+            };
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Lockfile der skills-CLI (E48 b, E50, HARNESS-FAKTEN). Fehlt die Datei am ersten Kandidaten,
+     * wird der nächste versucht; ist sie da, aber kein gültiges JSON oder trägt der Eintrag nicht die
+     * nötigen Felder, gibt es undefined zurück statt zu werfen: ein kaputtes Lockfile bricht die
+     * Erhebung nicht ab.
+     */
+    async skillLockEintrag(skillsVerzeichnis, name) {
+        for (const lockPfad of this.lockPfadKandidaten(skillsVerzeichnis)) {
+            const roh = await readFile(lockPfad, 'utf8').catch(() => undefined);
+            if (roh === undefined)
+                continue;
+            return this.lockEintragAusInhalt(roh, name);
+        }
+        return undefined;
+    }
+    /** SHA-256 über relativen Pfad und Inhalt aller Dateien, wie `computeSkillFolderHash` (E48 b). */
+    async ordnerHash(verzeichnis, name) {
+        const dateien = [];
+        await ordnerDateien(path.join(verzeichnis, name), '', dateien);
+        dateien.sort((a, b) => a.relativerPfad.localeCompare(b.relativerPfad));
+        const hash = createHash('sha256');
+        for (const datei of dateien) {
+            hash.update(datei.relativerPfad);
+            hash.update(datei.inhalt);
+        }
+        return hash.digest('hex');
+    }
 }

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). */
@@ -115,14 +113,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));
@@ -265,8 +286,10 @@ 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.
         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 +323,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 +336,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 +391,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,10 +1,10 @@
 // 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 { OrtNichtUnterstuetzt, SkillOrdnerUngueltig } from "../kern/modell.js";
 import { gitignoreEintragen, istGitRepo } from "./gitignore.js";
 const HERMES_VERZEICHNIS = '.hermes';
 const PROFILE_VERZEICHNIS = 'profiles';
@@ -96,10 +96,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 +111,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 +225,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 +331,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),
             },