hmgr 0.0.5 → 0.0.7

package/dist/adapter/git.js

@@ -2,6 +2,7 @@
 import { spawn } from 'node:child_process';
 import { readFile, readdir, mkdir, realpath, rm, stat } from 'node:fs/promises';
 import path from 'node:path';
+import { bundleLesen, istBundleDatei } from "./bundle-yaml.js";
 import { marketplaceLesen } from "./marketplace-json.js";
 import { SKILL_DATEI, skillAusPfad, skillName } from "./skill-md.js";
 import { BASIS_NAME, basisPfad, quelleZerlegen, refDekodieren, worktreePfad } from "./checkout-pfad.js";
@@ -28,13 +29,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('/'));
     }
@@ -94,6 +99,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 = [];
@@ -180,24 +193,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:
@@ -227,10 +248,61 @@ 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))),
             })),
         };
     }
+    /**
+     * Inhalte beliebiger Dateien eines Refs in einem Aufruf, dasselbe Bündel-Muster wie
+     * `skillMdInhalte`: `git cat-file --batch` holt beim Partial Clone die fehlenden Blobs gebündelt.
+     * Was nicht lesbar ist, fehlt in der Karte.
+     */
+    async dateiInhalte(basis, ref, pfade) {
+        if (pfade.length === 0)
+            return new Map();
+        const eingabe = `${pfade.map((p) => `${ref}:${p}`).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);
+    }
+    /**
+     * Bundle-Definitionen der Quelle (E69): jede Datei unter `bundles/`, gelesen wie der Marketplace
+     * über den Git-Baum statt über einen Checkout. Eine kaputte Datei ergibt einen Fehler-Eintrag,
+     * keinen Abbruch: die übrigen Bundles derselben Quelle bleiben nutzbar.
+     */
+    async bundles(quelle, ref) {
+        let dateien;
+        let inhalte;
+        if (quelle.art === 'lokal') {
+            dateien = (await dateienAufPlatte(quelle.pfad)).filter(istBundleDatei).sort();
+            inhalte = new Map();
+            for (const datei of dateien) {
+                const roh = await readFile(path.join(quelle.pfad, datei), 'utf8').catch(() => undefined);
+                if (roh !== undefined)
+                    inhalte.set(datei, roh);
+            }
+        }
+        else {
+            const basis = await this.basis(quelle);
+            const ausgabe = await this.git(['ls-tree', '-r', '--name-only', ref], basis);
+            dateien = ausgabe.split('\n').filter(istBundleDatei).sort();
+            inhalte = await this.dateiInhalte(basis, ref, dateien);
+        }
+        return dateien.map((datei) => {
+            const inhalt = inhalte.get(datei);
+            if (inhalt === undefined)
+                return { art: 'fehler', datei, fehler: 'Datei nicht lesbar' };
+            try {
+                return { art: 'bundle', datei, bundle: bundleLesen(inhalt, datei, quelle) };
+            }
+            catch (fehler) {
+                return { art: 'fehler', datei, fehler: fehler instanceof Error ? fehler.message : String(fehler) };
+            }
+        });
+    }
     async refs(quelle) {
         if (quelle.art === 'lokal')
             return [LOKAL_REF];
@@ -287,7 +359,11 @@ export class GitQuellen {
             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.
+        // 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 === '' ? '/**' : `/${skill.pfad}/`);
         await this.git(['sparse-checkout', 'set', '--no-cone', '--', ...muster], pfad);
@@ -348,6 +424,104 @@ export class GitQuellen {
         await this.git(['checkout', '--detach', checkout.ref], checkout.pfad);
         return { ergebnis: 'aktualisiert', von, nach };
     }
+    /**
+     * Geänderte Pfade zwischen zwei Commits (E70). `--no-renames` aus zwei Gründen: eine Umbenennung
+     * soll hier als Änderung an beiden Pfaden zählen, und die Ähnlichkeitsprüfung bräuchte die Blobs,
+     * die ein Partial Clone (`--filter=blob:none`) erst aus dem Netz holen müsste. Eine lokale Quelle
+     * hat keinen Checkout und damit keine zwei Commits (B11), sie kommt hier nie an.
+     */
+    async geaenderteDateien(quelle, von, nach) {
+        if (quelle.art === 'lokal')
+            return [];
+        try {
+            const basis = await this.basis(quelle);
+            const ausgabe = await this.git(['diff', '--name-only', '--no-renames', von, nach], basis);
+            return ausgabe.split('\n').filter((z) => z.length > 0);
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Skills, die in diesem Checkout auf der Platte liegen (E70): dieselbe Regel wie bei einer
+     * lokalen Quelle, nur auf das Worktree-Verzeichnis angewandt. Der Sparse-Checkout hat dort nur
+     * die gewählten Skills materialisiert (E22), also nennt der Update-Bericht auch nur diese.
+     */
+    async ausgecheckteSkills(checkout) {
+        const pfade = skillPfadeAusDateien(await dateienAufPlatte(checkout.pfad));
+        const inhalte = await inhalteAufPlatte(checkout.pfad, pfade);
+        const ersatzname = ersatznameDerQuelle(checkout.quelle);
+        return pfade.map((pfad) => skillAusPfad(pfad, inhalte.get(pfad), ersatzname));
+    }
+    /**
+     * Ein `git log --name-only` je Quelle statt eines Aufrufs je Skill (E70). Die Ausgabe wird
+     * gelesen, während sie entsteht, und der Lauf abgebrochen, sobald jeder gesuchte Pfad sein Datum
+     * hat: der jüngste Commit steht vorn, alles Ältere ist unnötig. Gemessen an einem Repo mit 20
+     * Skills und 401 Commits: 6 ms gegen 110 ms für 20 einzelne `git log -1`.
+     *
+     * Format: `%x00%cI` stellt jeder Datumszeile ein NUL voran, das in keinem Dateipfad vorkommt —
+     * daran trennen sich Kopf und Dateiliste. `--no-renames` hält die Ähnlichkeitsprüfung heraus, die
+     * beim Partial Clone Blobs nachladen würde. Scheitert der Aufruf (kein Repo, unbekannter Ref),
+     * bleibt die Karte leer, das ist kein Fehler.
+     */
+    async logDaten(cwd, ref, pfade) {
+        const daten = new Map();
+        const offen = new Set(pfade);
+        if (offen.size === 0)
+            return daten;
+        return await new Promise((erfuellen) => {
+            const kind = spawn('git', ['log', '--format=%x00%cI', '--name-only', '--no-renames', ref], {
+                cwd,
+                stdio: ['ignore', 'pipe', 'ignore'],
+                timeout: 300_000,
+                killSignal: 'SIGKILL',
+                env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+            });
+            let rest = '';
+            let datum;
+            const fertig = () => erfuellen(daten);
+            kind.on('error', fertig);
+            kind.on('close', fertig);
+            // Nach dem Abbruch schreibt git in eine Pipe, die niemand mehr liest: der Fehler darf den
+            // Prozess nicht mitnehmen, das Ergebnis steht da schon fest.
+            kind.stdout.on('error', () => { });
+            kind.stdout.on('data', (teil) => {
+                rest += teil.toString('utf8');
+                const zeilen = rest.split('\n');
+                rest = zeilen.pop() ?? '';
+                for (const zeile of zeilen) {
+                    if (zeile.startsWith('\0')) {
+                        datum = zeile.slice(1);
+                        continue;
+                    }
+                    if (zeile.length === 0 || datum === undefined)
+                        continue;
+                    for (const pfad of [...offen])
+                        // Ein Wurzel-Skill (Pfad `''`, E11-Nachtrag) ist das ganze Repo: jede Datei zählt.
+                        if (pfad === '' || zeile === pfad || zeile.startsWith(`${pfad}/`)) {
+                            daten.set(pfad, datum);
+                            offen.delete(pfad);
+                        }
+                }
+                if (offen.size === 0)
+                    kind.kill('SIGTERM');
+            });
+        });
+    }
+    /**
+     * Änderungsdatum je Skill (E70, F70=O1). Eine lokale Quelle hat keinen Basis-Clone, wohl aber
+     * meist eine Arbeitskopie (B11): dort zählt der HEAD-Stand auf der Platte, wie überall sonst bei
+     * lokalen Quellen. Ist der Pfad kein Git-Repo, bleibt die Karte leer und der Katalog nennt für
+     * diese Quelle kein Datum.
+     */
+    async letzteAenderungen(quelle, ref, pfade) {
+        if (quelle.art === 'lokal')
+            return await this.logDaten(quelle.pfad, 'HEAD', pfade);
+        const basis = await this.basis(quelle).catch(() => undefined);
+        if (basis === undefined)
+            return new Map();
+        return await this.logDaten(basis, ref, pfade);
+    }
     /**
      * Checkout von der Platte nehmen. Ein Worktree steht im Basis-Clone eingetragen, ein blankes
      * Löschen des Verzeichnisses ließe den Eintrag stehen und ein späterer `worktree add` auf

package/dist/adapter/hermes.js

@@ -4,8 +4,9 @@ import { readFileSync, realpathSync } from 'node:fs';
 import { mkdir, readFile, readdir, rm, stat, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { Document, isMap, isScalar, isSeq, parseDocument } from 'yaml';
-import { OrtNichtUnterstuetzt, SkillOrdnerUngueltig } from "../kern/modell.js";
+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;
@@ -358,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})`);

package/dist/adapter/mcp-katalog.js

@@ -0,0 +1,124 @@
+// Liest den persönlichen MCP-Katalog ~/.hmgr/mcp.yaml (E61). hmgr schreibt ihn nie.
+import { readFile } from 'node:fs/promises';
+import { parseDocument } from 'yaml';
+import { McpKatalogFehler } from "../kern/modell.js";
+const STDIO_FELDER = new Set(['command', 'args', 'env']);
+const URL_FELDER = new Set(['url', 'headers']);
+function fehlertext(fehler) {
+    return fehler instanceof Error ? fehler.message : String(fehler);
+}
+function istObjekt(wert) {
+    return typeof wert === 'object' && wert !== null && !Array.isArray(wert);
+}
+/** Ein optionales Textfeld: fehlt es oder ist es leer, bleibt es weg, kein Fehler. */
+function feldText(pfad, name, o, feld) {
+    if (!(feld in o))
+        return undefined;
+    const wert = o[feld];
+    if (typeof wert !== 'string')
+        throw new McpKatalogFehler(pfad, `Eintrag „${name}": Feld „${feld}" muss Text sein`);
+    const getrimmt = wert.trim();
+    return getrimmt.length === 0 ? undefined : wert;
+}
+/** Eine Zeichenkette-zu-Zeichenkette-Map wie `env` oder `headers`, oder undefined ohne das Feld. */
+function mapLesen(pfad, name, wert, feld) {
+    if (wert === undefined)
+        return undefined;
+    if (!istObjekt(wert))
+        throw new McpKatalogFehler(pfad, `Eintrag „${name}": konfig.${feld} muss ein Objekt sein`);
+    const ergebnis = {};
+    for (const [k, v] of Object.entries(wert)) {
+        if (typeof v !== 'string')
+            throw new McpKatalogFehler(pfad, `Eintrag „${name}": konfig.${feld}.${k} muss Text sein`);
+        ergebnis[k] = v;
+    }
+    return ergebnis;
+}
+/** Eine Liste von Zeichenketten wie `args`, oder undefined ohne das Feld. */
+function argsLesen(pfad, name, wert) {
+    if (wert === undefined)
+        return undefined;
+    if (!Array.isArray(wert))
+        throw new McpKatalogFehler(pfad, `Eintrag „${name}": konfig.args muss eine Liste sein`);
+    return wert.map((eintrag, i) => {
+        if (typeof eintrag !== 'string')
+            throw new McpKatalogFehler(pfad, `Eintrag „${name}": konfig.args[${i}] muss Text sein`);
+        return eintrag;
+    });
+}
+function konfigLesen(pfad, name, k) {
+    const hatCommand = 'command' in k;
+    const hatUrl = 'url' in k;
+    if (hatCommand && hatUrl)
+        throw new McpKatalogFehler(pfad, `Eintrag „${name}": konfig darf nicht zugleich „command" und „url" haben`);
+    if (hatCommand) {
+        for (const feld of Object.keys(k))
+            if (!STDIO_FELDER.has(feld))
+                throw new McpKatalogFehler(pfad, `Eintrag „${name}": unbekanntes Feld „${feld}" in konfig`);
+        const command = k['command'];
+        if (typeof command !== 'string' || command.trim().length === 0)
+            throw new McpKatalogFehler(pfad, `Eintrag „${name}": konfig.command muss nicht leerer Text sein`);
+        const args = argsLesen(pfad, name, k['args']);
+        const env = mapLesen(pfad, name, k['env'], 'env');
+        return { command, ...(args === undefined ? {} : { args }), ...(env === undefined ? {} : { env }) };
+    }
+    if (hatUrl) {
+        for (const feld of Object.keys(k))
+            if (!URL_FELDER.has(feld))
+                throw new McpKatalogFehler(pfad, `Eintrag „${name}": unbekanntes Feld „${feld}" in konfig`);
+        const url = k['url'];
+        if (typeof url !== 'string' || url.trim().length === 0)
+            throw new McpKatalogFehler(pfad, `Eintrag „${name}": konfig.url muss nicht leerer Text sein`);
+        const headers = mapLesen(pfad, name, k['headers'], 'headers');
+        return { url, ...(headers === undefined ? {} : { headers }) };
+    }
+    throw new McpKatalogFehler(pfad, `Eintrag „${name}": konfig braucht entweder „command" oder „url"`);
+}
+function eintragLesen(pfad, name, roh) {
+    if (!istObjekt(roh))
+        throw new McpKatalogFehler(pfad, `Eintrag „${name}" ist kein Objekt`);
+    const beschreibung = roh['beschreibung'];
+    if (typeof beschreibung !== 'string' || beschreibung.trim().length === 0)
+        throw new McpKatalogFehler(pfad, `Eintrag „${name}" braucht eine Beschreibung (Feld „beschreibung")`);
+    const homepage = feldText(pfad, name, roh, 'homepage');
+    const notizen = feldText(pfad, name, roh, 'notizen');
+    const konfigRoh = roh['konfig'];
+    if (!istObjekt(konfigRoh))
+        throw new McpKatalogFehler(pfad, `Eintrag „${name}" braucht einen Konfigblock (Feld „konfig")`);
+    const konfig = konfigLesen(pfad, name, konfigRoh);
+    return {
+        name,
+        beschreibung,
+        ...(homepage === undefined ? {} : { homepage }),
+        ...(notizen === undefined ? {} : { notizen }),
+        konfig,
+    };
+}
+export class DateiMcpKatalog {
+    pfad;
+    constructor(pfad) {
+        this.pfad = pfad;
+    }
+    /** Fehlende Datei: leerer Katalog, kein Fehler. Kaputtes YAML oder falsches Format: Fehler mit Pfad. */
+    async lesen() {
+        let text;
+        try {
+            text = await readFile(this.pfad, 'utf8');
+        }
+        catch {
+            return [];
+        }
+        let daten;
+        try {
+            daten = parseDocument(text, { strict: true }).toJS();
+        }
+        catch (fehler) {
+            throw new McpKatalogFehler(this.pfad, `kaputtes YAML: ${fehlertext(fehler)}`);
+        }
+        if (daten === null || daten === undefined)
+            return [];
+        if (!istObjekt(daten))
+            throw new McpKatalogFehler(this.pfad, 'die Datei muss ein Objekt mit einem Eintrag je MCP-Name sein');
+        return Object.entries(daten).map(([name, roh]) => eintragLesen(this.pfad, name, roh));
+    }
+}

package/dist/adapter/paket-version.js

@@ -0,0 +1,25 @@
+// Die Version des Pakets, gelesen aus seiner package.json (E72). Keine Kopie im Code: eine
+// zweite Stelle mit derselben Zahl geht früher oder später auseinander.
+import { readFileSync } from 'node:fs';
+/**
+ * Die package.json liegt in jeder Lage zwei Ebenen über diesem Modul: in der Quelle
+ * `src/adapter/` → Wurzel, im Build `dist/adapter/` → Wurzel, in der npm-Installation
+ * `node_modules/hmgr/dist/adapter/` → `node_modules/hmgr/`, im gepackten App-Bundle
+ * `app.asar/dist/adapter/` → `app.asar/`. Aufgelöst über `import.meta.url`, damit weder das
+ * Arbeitsverzeichnis noch der Aufrufweg hineinspielt.
+ *
+ * Bewusst kein Import mit `with { type: 'json' }`: der zöge die package.json beim Bauen nach
+ * `dist` und legte damit eine zweite Wahrheit an.
+ */
+const PAKET_JSON = new URL('../../package.json', import.meta.url);
+let gemerkt;
+/** Die Versionsnummer aus der package.json des Pakets, etwa „0.0.6". */
+export function paketVersion() {
+    if (gemerkt === undefined) {
+        const inhalt = JSON.parse(readFileSync(PAKET_JSON, 'utf8'));
+        if (typeof inhalt.version !== 'string')
+            throw new Error(`Die package.json unter ${PAKET_JSON.pathname} nennt keine Version.`);
+        gemerkt = inhalt.version;
+    }
+    return gemerkt;
+}

package/dist/adapter/quelle-text.js

@@ -1,8 +1,17 @@
 import path from 'node:path';
+import { istWindowsLaufwerkspfad } from "../kern/quelle-ort.js";
 export { quelleAlsText } from "../kern/modell.js";
-/** URL heißt Git-Quelle mit Checkout, ein nackter Pfad heißt lokale Arbeitskopie ohne Clone (B11). */
+/**
+ * URL heißt Git-Quelle mit Checkout, ein nackter Pfad heißt lokale Arbeitskopie ohne Clone (B11).
+ *
+ * Ein Windows-Laufwerkspfad ist ein nackter Pfad (E65/B12): `C:\work\quelle` traf sonst die
+ * scp-Regel `host:pfad` — Host „C" — und `hmgr source add C:\work\quelle` legte die Arbeitskopie
+ * als Git-Quelle mit Remote an statt als lokale. Sichtbar wurde das am Anzeigenamen „\work\quelle".
+ */
 export function quelleAusText(text) {
     const roh = text.trim();
+    if (istWindowsLaufwerkspfad(roh))
+        return { art: 'lokal', pfad: path.resolve(roh) };
     if (roh.includes('://') || /^(?:[^@/\s]+@)?[^@/:\s]+:[^/\s]/.test(roh))
         return { art: 'git', url: roh };
     return { art: 'lokal', pfad: path.resolve(roh) };

package/dist/adapter/skill-md.js

@@ -1,9 +1,10 @@
 // Name, Beschreibung und Besonderheiten eines Skills aus dem Frontmatter der SKILL.md (E32, E39, E55).
 import { parse } from 'yaml';
+import { ohneBom } from "./datei-text.js";
 export const SKILL_DATEI = 'SKILL.md';
 /** Der Block zwischen der ersten Zeile `---` und der nächsten Zeile `---`. Fehlt er, undefined. */
 function frontmatter(inhalt) {
-    const zeilen = inhalt.replace(/^\uFEFF/, '').split('\n');
+    const zeilen = ohneBom(inhalt).split('\n');
     if (zeilen[0]?.trimEnd() !== '---')
         return undefined;
     for (let i = 1; i < zeilen.length; i += 1)

package/dist/adapter/umgebung.js

@@ -0,0 +1,43 @@
+// Prozess-Umgebung und .env-Dateien, für die F39-Prüfung beim MCP-Einhängen (E61).
+import { readFile } from 'node:fs/promises';
+export class ProzessUmgebung {
+    env;
+    constructor(env = process.env) {
+        this.env = env;
+    }
+    variablen() {
+        const ergebnis = {};
+        for (const [name, wert] of Object.entries(this.env))
+            if (wert !== undefined)
+                ergebnis[name] = wert;
+        return ergebnis;
+    }
+    /**
+     * Liest NAME=wert-Zeilen. Leere Zeilen und solche, die mit „#" beginnen, zählen nicht. Werte in
+     * einfachen oder doppelten Anführungszeichen werden davon befreit, sonst unverändert übernommen.
+     */
+    async envDatei(pfad) {
+        let text;
+        try {
+            text = await readFile(pfad, 'utf8');
+        }
+        catch {
+            return {};
+        }
+        const ergebnis = {};
+        for (const zeile of text.split('\n')) {
+            const getrimmt = zeile.trim();
+            if (getrimmt.length === 0 || getrimmt.startsWith('#'))
+                continue;
+            const trenner = getrimmt.indexOf('=');
+            if (trenner <= 0)
+                continue;
+            const name = getrimmt.slice(0, trenner).trim();
+            let wert = getrimmt.slice(trenner + 1).trim();
+            if (wert.length >= 2 && ((wert.startsWith('"') && wert.endsWith('"')) || (wert.startsWith("'") && wert.endsWith("'"))))
+                wert = wert.slice(1, -1);
+            ergebnis[name] = wert;
+        }
+        return ergebnis;
+    }
+}

package/dist/adapter/vergleich.js

@@ -0,0 +1,20 @@
+// Gemeinsames Modul der Adapter: Vergleich zweier aus YAML oder JSON gelesener Werte.
+/**
+ * Tiefer Vergleich, ohne Rücksicht auf die Schlüsselreihenfolge. Gebraucht, wo ein Adapter einen
+ * schon vorhandenen MCP-Eintrag gegen den Katalogblock hält (E61): gleicher Block heißt „schon
+ * eingehängt", ein abweichender wird nie stillschweigend überschrieben.
+ */
+export function tiefGleich(a, b) {
+    if (a === b)
+        return true;
+    if (Array.isArray(a) || Array.isArray(b))
+        return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((v, i) => tiefGleich(v, b[i]));
+    if (typeof a === 'object' && a !== null && typeof b === 'object' && b !== null) {
+        const ak = Object.keys(a).sort();
+        const bk = Object.keys(b).sort();
+        if (ak.length !== bk.length || ak.some((k, i) => k !== bk[i]))
+            return false;
+        return ak.every((k) => tiefGleich(a[k], b[k]));
+    }
+    return false;
+}

package/dist/adapter/zustand-json.js

@@ -1,7 +1,8 @@
 // Lokaler Zustand als eine JSON-Datei, Standard ~/.hmgr/state.json (E29).
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
-import { leererZustand } from "../ports/zustand.js";
+import { ZUSTAND_FASSUNG, leererZustand, } from "../ports/zustand.js";
+import { ohneBom } from "./datei-text.js";
 export class ZustandJson {
     pfad;
     constructor(pfad) {
@@ -11,8 +12,11 @@ export class ZustandJson {
         const roh = await readFile(this.pfad, 'utf8').catch(() => undefined);
         if (roh === undefined)
             return leererZustand();
-        const daten = JSON.parse(roh);
+        const daten = JSON.parse(ohneBom(roh));
         return {
+            // Fehlt das Feld (state.json vor E69), ist es die erste Fassung: alles ohne Bundles.
+            // Geschrieben wird danach in der aktuellen Fassung, ein Rückweg ist nicht vorgesehen.
+            fassung: typeof daten.fassung === 'number' ? daten.fassung : 1,
             quellen: (daten.quellen ?? []),
             arbeitsverzeichnisse: (daten.arbeitsverzeichnisse ?? []),
             bindungen: (daten.bindungen ?? []),
@@ -20,10 +24,14 @@ export class ZustandJson {
             aktiveHarnesses: (daten.aktiveHarnesses ?? ['claude-code']),
             // Fehlt das Feld (state.json vor E43), gilt: nichts ignoriert.
             ignorierteEintraege: (daten.ignorierteEintraege ?? []),
+            // Fehlt das Feld (state.json vor E69), gilt: kein Bundle installiert.
+            bundleInstallationen: (daten.bundleInstallationen ?? []),
         };
     }
     async schreiben(zustand) {
         await mkdir(path.dirname(this.pfad), { recursive: true });
-        await writeFile(this.pfad, `${JSON.stringify(zustand, null, 2)}\n`);
+        // Immer in der aktuellen Fassung, egal welche gelesen wurde: das Lesen hat den Bestand schon
+        // auf die aktuelle Form gebracht, ein alter Vermerk in der Datei wäre danach eine Lüge.
+        await writeFile(this.pfad, `${JSON.stringify({ ...zustand, fassung: ZUSTAND_FASSUNG }, null, 2)}\n`);
     }
 }