hmgr 0.0.6 → 0.0.12

package/dist/adapter/agents.js

@@ -4,15 +4,22 @@ import { mkdir, stat } from 'node:fs/promises';
 import path from 'node:path';
 import { OrtNichtUnterstuetzt } from "../kern/modell.js";
 import { gitignoreEintragen, istGitRepo } from "./gitignore.js";
+import { nurHome } from "./heime.js";
 const AGENTS_VERZEICHNIS = '.agents';
 const SKILLS_ORDNER = 'skills';
 const GITIGNORE_ZEILE = '.agents/';
 export class Agents {
     name = 'agents';
-    home;
-    /** `home` ist das HOME des Nutzers, das Verzeichnis liegt darunter als `.agents`. */
-    constructor(home) {
-        this.home = home;
+    heime;
+    /**
+     * `heime` sagt, wo das Homedir liegt (E78, F89): umstellbar, aber ohne zusätzliche Homedirs —
+     * die gibt es bisher nur bei claude-code. Ein blanker Pfad steht für „genau dieses Home".
+     */
+    constructor(heime) {
+        this.heime = typeof heime === 'string' ? nurHome(heime) : heime;
+    }
+    get home() {
+        return this.heime.primaer(this.name);
     }
     /**
      * Wie bei den anderen Harness-Typen zählt das angelegte Verzeichnis. Legt es niemand an, gibt es
@@ -25,8 +32,10 @@ export class Agents {
         return ['home', 'arbeitsverzeichnis'];
     }
     zielVerzeichnis(ort) {
+        // Über `heime.pfad` statt über `this.home`: nennt der Ort ein zusätzliches Homedir, wirft der
+        // Port (E78). agents hat die Fähigkeit nicht, ein solcher Ort dürfte hier gar nicht ankommen.
         if (ort.art === 'home')
-            return path.join(this.home, AGENTS_VERZEICHNIS, SKILLS_ORDNER);
+            return path.join(this.heime.pfad(this.name, ort), AGENTS_VERZEICHNIS, SKILLS_ORDNER);
         if (ort.art === 'arbeitsverzeichnis')
             return path.join(ort.pfad, AGENTS_VERZEICHNIS, SKILLS_ORDNER);
         throw new OrtNichtUnterstuetzt(this.name, ort.art);

package/dist/adapter/bundle-yaml.js

@@ -0,0 +1,87 @@
+// Liest eine Bundle-Definition aus einer Quelle (E69). hmgr schreibt solche Dateien nie.
+import { parseDocument } from 'yaml';
+import { BundleDateiFehler } from "../kern/modell.js";
+import { quelleAusText } from "./quelle-text.js";
+/** Konvention für Bundle-Definitionen in einer Quelle (E69): `bundles/<name>.yaml`. */
+export const BUNDLE_VERZEICHNIS = 'bundles';
+/**
+ * Ob ein Pfad in der Quelle eine Bundle-Definition ist: eine Datei direkt unter `bundles/`, mit
+ * Endung `.yaml` oder `.yml`. Nichts Verschachteltes — die Konvention nennt genau eine Ebene, und
+ * ein Unterordner wäre eine stille zweite Bedeutung.
+ */
+export function istBundleDatei(pfad) {
+    return /^bundles\/[^/]+\.(?:yaml|yml)$/.test(pfad);
+}
+/** Der Dateiname ohne Verzeichnis und Endung: Ersatzname, wenn das Feld `name` fehlt. */
+export function bundleDateiName(pfad) {
+    return pfad.replace(/^bundles\//, '').replace(/\.(?:yaml|yml)$/, '');
+}
+function fehlertext(fehler) {
+    return fehler instanceof Error ? fehler.message : String(fehler);
+}
+function istObjekt(wert) {
+    return typeof wert === 'object' && wert !== null && !Array.isArray(wert);
+}
+/** Erlaubte Felder auf oberster Ebene und je Mitglied. Alles andere ist ein Fehler mit Feldnamen. */
+const FELDER = new Set(['name', 'description', 'skills']);
+const MITGLIED_FELDER = new Set(['source', 'path']);
+function mitgliedLesen(datei, roh, i) {
+    if (!istObjekt(roh))
+        throw new BundleDateiFehler(datei, `skills[${i}] muss ein Objekt mit source und path sein`);
+    for (const feld of Object.keys(roh))
+        if (!MITGLIED_FELDER.has(feld))
+            throw new BundleDateiFehler(datei, `skills[${i}]: unbekanntes Feld „${feld}"`);
+    const source = roh['source'];
+    if (typeof source !== 'string' || source.trim().length === 0)
+        throw new BundleDateiFehler(datei, `skills[${i}].source muss die Adresse einer Quelle sein (URL oder Pfad)`);
+    const pfad = roh['path'];
+    if (typeof pfad !== 'string' || pfad.trim().length === 0)
+        throw new BundleDateiFehler(datei, `skills[${i}].path muss der Pfad des Skills in der Quelle sein`);
+    // Führende und abschließende Schrägstriche fallen weg: `skills/x/` und `skills/x` meinen denselben
+    // Ordner, und der Katalog führt ihn ohne (E11). Ein Wurzel-Skill (leerer Pfad) ist nicht
+    // adressierbar — er hieße in der Definition „", das ist kein Text und fliegt oben schon auf.
+    return { quelle: quelleAusText(source.trim()), pfad: pfad.trim().replace(/^\/+/, '').replace(/\/+$/, '') };
+}
+/**
+ * Eine Bundle-Definition aus dem YAML-Text lesen und validieren (E69). `datei` ist der Pfad in der
+ * Quelle, er dient als Ersatzname (ohne Verzeichnis und Endung), wenn das Feld `name` fehlt: der
+ * Dateiname ist Konvention, das Feld ist die Aussage des Autors — dieselbe Rangfolge wie beim
+ * Skill-Namen (E32). `quelle` ist die Quelle, in der die Datei liegt.
+ */
+export function bundleLesen(text, datei, quelle) {
+    let daten;
+    try {
+        const dokument = parseDocument(text, { strict: true });
+        // `parseDocument` sammelt Syntaxfehler, statt zu werfen: ohne diese Prüfung käme eine kaputte
+        // Datei als halb gelesenes Objekt durch und der Nutzer bekäme eine Meldung über ein Feld statt
+        // über die Datei.
+        const erster = dokument.errors[0];
+        if (erster !== undefined)
+            throw new BundleDateiFehler(datei, `kaputtes YAML: ${erster.message}`);
+        daten = dokument.toJS();
+    }
+    catch (fehler) {
+        if (fehler instanceof BundleDateiFehler)
+            throw fehler;
+        throw new BundleDateiFehler(datei, `kaputtes YAML: ${fehlertext(fehler)}`);
+    }
+    if (!istObjekt(daten))
+        throw new BundleDateiFehler(datei, 'die Datei muss ein Objekt mit name, description und skills sein');
+    for (const feld of Object.keys(daten))
+        if (!FELDER.has(feld))
+            throw new BundleDateiFehler(datei, `unbekanntes Feld „${feld}"`);
+    const rohName = daten['name'];
+    if (rohName !== undefined && (typeof rohName !== 'string' || rohName.trim().length === 0))
+        throw new BundleDateiFehler(datei, 'name muss nicht leerer Text sein');
+    const name = typeof rohName === 'string' ? rohName.trim() : bundleDateiName(datei);
+    const beschreibung = daten['description'];
+    if (typeof beschreibung !== 'string' || beschreibung.trim().length === 0)
+        throw new BundleDateiFehler(datei, 'description muss nicht leerer Text sein');
+    const skills = daten['skills'];
+    if (!Array.isArray(skills))
+        throw new BundleDateiFehler(datei, 'skills muss eine Liste sein');
+    if (skills.length === 0)
+        throw new BundleDateiFehler(datei, 'skills darf nicht leer sein');
+    const mitglieder = skills.map((roh, i) => mitgliedLesen(datei, roh, i));
+    return { name, beschreibung: beschreibung.trim(), mitglieder, quelle, datei };
+}

package/dist/adapter/claude-code.js

@@ -1,12 +1,24 @@
 // Claude Code: Grundverhalten plus Plugins und MCP-Server über die claude-CLI (E16, E24, E27, E61).
 import spawn from 'cross-spawn';
 import { realpathSync } from 'node:fs';
-import { mkdir, readFile, stat } from 'node:fs/promises';
+import { readFile, stat } from 'node:fs/promises';
 import path from 'node:path';
-import { McpAbweichenderEintrag, McpNichtInGeteilterDatei, McpNurGeteilterFundort, McpUebernahmeNichtMoeglich, McpUebernahmeUnvollstaendig, OrtNichtUnterstuetzt, pluginSchluessel, } from "../kern/modell.js";
+import { HeimOhneCliZugriff, McpAbweichenderEintrag, McpNichtInGeteilterDatei, McpNurGeteilterFundort, McpUebernahmeNichtMoeglich, McpUebernahmeUnvollstaendig, OrtNichtUnterstuetzt, pluginSchluessel, } from "../kern/modell.js";
 import { ohneBom } from "./datei-text.js";
+import { LokalerZugriff } from "./dateisystem.js";
 import { gitignoreEintragen, istGitRepo } from "./gitignore.js";
+import { heimVerbinden, nurHome } from "./heime.js";
 import { tiefGleich } from "./vergleich.js";
+const CLAUDE_VERZEICHNIS = '.claude';
+const SKILLS_ORDNER = 'skills';
+/**
+ * Die Adresse eines zusätzlichen Homedirs an diesem Ort (E78), sonst `undefined`. Was die
+ * claude-CLI angeht — MCP-Server, Plugins —, gilt nur für das primäre Homedir: die CLI auf diesem
+ * Rechner kennt die Konfiguration einer WSL-Distro nicht.
+ */
+function zusaetzlichesHeim(ort) {
+    return ort.art === 'home' ? ort.heim : undefined;
+}
 const GITIGNORE_ZEILE = '.claude/';
 /**
  * Standard-Ausführer: `claude` vom PATH. Ein Fehlschlag wird zum Code, nicht zur Ausnahme.
@@ -113,6 +125,9 @@ class ClaudePlugins {
      * Startverzeichnis ab, mit dem Zielverzeichnis als cwd landete sie unter `.claude/skills/`.
      */
     scope(ziel) {
+        const heim = zusaetzlichesHeim(ziel.ort);
+        if (heim !== undefined)
+            throw new HeimOhneCliZugriff(this.harness.name, heim, 'Plugins');
         if (ziel.ort.art === 'home')
             return { scope: 'user' };
         if (ziel.ort.art === 'arbeitsverzeichnis')
@@ -219,6 +234,7 @@ async function projektMcpJsonLesen(verzeichnis) {
 class ClaudeMcp {
     harness;
     ausfuehrer;
+    /** Das primäre Homedir, jedes Mal frisch: es lässt sich zur Laufzeit umstellen (E78, F89). */
     home;
     constructor(harness, ausfuehrer, home) {
         this.harness = harness;
@@ -232,6 +248,9 @@ class ClaudeMcp {
         return 'Claude Code übernimmt die Änderung mit der nächsten Sitzung.';
     }
     scope(ort) {
+        const heim = zusaetzlichesHeim(ort);
+        if (heim !== undefined)
+            throw new HeimOhneCliZugriff(this.harness.name, heim, 'MCP-Server');
         if (ort.art === 'home')
             return { scope: 'user' };
         if (ort.art === 'arbeitsverzeichnis')
@@ -343,6 +362,9 @@ class ClaudeMcp {
      * sich Arbeitsverzeichnisse aber so, wie der Nutzer sie genannt hat, also zählen beide.
      */
     async mcpServersAm(ort) {
+        const heim = zusaetzlichesHeim(ort);
+        if (heim !== undefined)
+            throw new HeimOhneCliZugriff(this.harness.name, heim, 'MCP-Server');
         const daten = await this.claudeJsonLesen();
         if (ort.art === 'home')
             return mcpServersVon(daten);
@@ -355,7 +377,7 @@ class ClaudeMcp {
     }
     async claudeJsonLesen() {
         try {
-            const text = await readFile(path.join(this.home, '.claude.json'), 'utf8');
+            const text = await readFile(path.join(this.home(), '.claude.json'), 'utf8');
             return JSON.parse(ohneBom(text));
         }
         catch {
@@ -365,29 +387,42 @@ class ClaudeMcp {
 }
 export class ClaudeCode {
     name = 'claude-code';
-    home;
+    heime;
     ausfuehrer;
+    /** Zugriff je Ort (E78): lokal wie bisher, für ein WSL-Heim die Bridge. */
+    zugriffFuer;
     /** Wird von `vorhanden()` gesetzt, sobald die claude-CLI auf dem PATH liegt. */
     plugins;
     /** Wird von `vorhanden()` gesetzt, sobald die claude-CLI auf dem PATH liegt (E61). */
     mcp;
     geprueft = false;
-    constructor(home, ausfuehrer = claudeAusfuehrer) {
-        this.home = home;
+    /**
+     * `heime` sagt, wo die Homedirs liegen (E78): das primäre und, seit F87, zusätzliche in einer
+     * WSL-Distro. Ein blanker Pfad steht weiterhin für „nur dieses eine Home", damit Tests und
+     * Aufrufer ohne Zustand unverändert bleiben.
+     */
+    constructor(heime, ausfuehrer = claudeAusfuehrer, zugriffFuer) {
+        this.heime = typeof heime === 'string' ? nurHome(heime) : heime;
         this.ausfuehrer = ausfuehrer;
+        const lokal = new LokalerZugriff();
+        this.zugriffFuer = zugriffFuer ?? (() => lokal);
     }
     /**
-     * Claude Code liegt auf dem Rechner, wenn es sein Home angelegt hat. Die Plugin- und
+     * Claude Code liegt auf dem Rechner, wenn es sein Home angelegt hat — oder wenn ein zusätzliches
+     * Homedir eingetragen ist (E78): wer eines eingetragen hat, hat Claude Code dort laufen, und ein
+     * Windows-Home ohne `.claude` soll die WSL-Ziele nicht mit verschwinden lassen. Die Plugin- und
      * MCP-Fähigkeit kommen dazu, sobald `claude --version` durchläuft: ohne CLI gibt es beides nicht.
      */
     async vorhanden() {
-        const da = (await stat(path.join(this.home, '.claude')).catch(() => undefined)) !== undefined;
+        const primaer = this.heime.primaer(this.name);
+        const da = (await stat(path.join(primaer, CLAUDE_VERZEICHNIS)).catch(() => undefined)) !== undefined ||
+            this.heime.zusaetzliche(this.name).length > 0;
         if (!this.geprueft) {
             this.geprueft = true;
             const { code } = await this.ausfuehrer(['--version']).catch(() => ({ code: 1 }));
             if (code === 0) {
                 this.plugins = new ClaudePlugins(this, this.ausfuehrer);
-                this.mcp = new ClaudeMcp(this, this.ausfuehrer, this.home);
+                this.mcp = new ClaudeMcp(this, this.ausfuehrer, () => this.heime.primaer(this.name));
             }
         }
         return da;
@@ -395,15 +430,21 @@ export class ClaudeCode {
     orte() {
         return ['home', 'arbeitsverzeichnis'];
     }
+    /** Fähigkeit: zusätzliche Homedirs (E78, F87). Das Layout ist ein fester Ordner, kein Konfigeintrag. */
+    zusaetzlicheHeime() {
+        return true;
+    }
     zielVerzeichnis(ort) {
         if (ort.art === 'home')
-            return path.join(this.home, '.claude', 'skills');
+            return heimVerbinden(ort, this.heime.pfad(this.name, ort), CLAUDE_VERZEICHNIS, SKILLS_ORDNER);
         if (ort.art === 'arbeitsverzeichnis')
-            return path.join(ort.pfad, '.claude', 'skills');
+            return path.join(ort.pfad, CLAUDE_VERZEICHNIS, SKILLS_ORDNER);
         throw new OrtNichtUnterstuetzt(this.name, ort.art);
     }
     async vorbereiten(ort) {
-        await mkdir(this.zielVerzeichnis(ort), { recursive: true });
+        // Über den Zugriff, nicht über `mkdir`: in einem WSL-Heim liegt das Verzeichnis im
+        // Linux-Dateisystem, wo Windows-Node nicht anlegen kann (E78).
+        await this.zugriffFuer(ort).verzeichnisAnlegen(this.zielVerzeichnis(ort));
         if (ort.art === 'arbeitsverzeichnis' && (await istGitRepo(ort.pfad)))
             await gitignoreEintragen(ort.pfad, GITIGNORE_ZEILE);
     }

package/dist/adapter/dateisystem.js

@@ -45,15 +45,63 @@ export function linkFehlerHinweis(plattform = process.platform) {
         ? 'Aktiviere den Windows-Entwicklermodus (Einstellungen → System → Für Entwickler) oder starte hmgr mit Administratorrechten.'
         : 'Prüfe die Schreibrechte auf das Zielverzeichnis und ob das Linkziel vorhanden ist.';
 }
+/**
+ * Zugriff auf das lokale Dateisystem (E78): der Weg, den hmgr immer schon ging, jetzt hinter dem
+ * Port. Linkziele brauchen keine Übersetzung, sie stehen schon in der Schreibweise des Rechners.
+ */
+export class LokalerZugriff {
+    trenner = path.sep;
+    verbinden(verzeichnis, name) {
+        return path.join(verzeichnis, name);
+    }
+    async namen(verzeichnis) {
+        return await readdir(verzeichnis).catch(() => []);
+    }
+    async info(pfad) {
+        const roh = await lstat(pfad).catch(() => undefined);
+        if (roh === undefined)
+            return undefined;
+        if (!roh.isSymbolicLink())
+            return { istLink: false, istVerzeichnis: roh.isDirectory() };
+        return { istLink: true, istVerzeichnis: (await stat(pfad).catch(() => undefined))?.isDirectory() === true };
+    }
+    async linkZiel(pfad) {
+        const info = await lstat(pfad).catch(() => undefined);
+        if (!info || !info.isSymbolicLink())
+            return undefined;
+        // Junctions meldet Node als Symlink, ihr Ziel aber mit `\\?\`-Präfix (E66): erst kürzen, dann
+        // auflösen, sonst ergäbe `path.resolve` einen Pfad, der zu keinem Soll-Ziel passt.
+        return path.resolve(path.dirname(pfad), ohneWindowsPraefix(await readlink(pfad)));
+    }
+    async verzeichnisAnlegen(pfad) {
+        await mkdir(pfad, { recursive: true });
+    }
+    async linkAnlegen(pfad, hostZiel) {
+        await symlink(hostZiel, pfad, symlinkTyp());
+    }
+    async linkEntfernen(pfad) {
+        await unlink(pfad);
+    }
+    async loeschen(pfad) {
+        await rm(pfad, { recursive: true, force: true });
+    }
+}
 export class DateisystemZiele {
     wurzel;
     zustand;
     /** $XDG_STATE_HOME, falls gesetzt und nicht leer, für den vorrangigen Lockfile-Ort (E50). */
     xdgStateHome;
-    constructor(wurzel, zustand, xdgStateHome) {
+    /**
+     * Welcher Zugriff zu welchem Ziel gehört (E78): lokal wie bisher, für ein WSL-Heim die Bridge.
+     * Ohne Angabe ist alles lokal — so bleibt der Adapter ohne Windows-Umgebung derselbe wie vorher.
+     */
+    zugriffFuer;
+    lokal = new LokalerZugriff();
+    constructor(wurzel, zustand, xdgStateHome, zugriffFuer) {
         this.wurzel = wurzel;
         this.zustand = zustand;
         this.xdgStateHome = xdgStateHome;
+        this.zugriffFuer = zugriffFuer ?? (() => this.lokal);
     }
     async quellen() {
         return (await this.zustand.lesen()).quellen;
@@ -105,37 +153,22 @@ export class DateisystemZiele {
         }
         return undefined;
     }
-    async linkZiel(verzeichnis, name) {
-        const pfad = path.join(verzeichnis, name);
-        const info = await lstat(pfad).catch(() => undefined);
-        if (!info || !info.isSymbolicLink())
-            return undefined;
-        // Junctions meldet Node als Symlink, ihr Ziel aber mit `\\?\`-Präfix (E66): erst kürzen, dann
-        // auflösen, sonst ergäbe `path.resolve` einen Pfad, der zu keinem Soll-Ziel passt.
-        return path.resolve(verzeichnis, ohneWindowsPraefix(await readlink(pfad)));
-    }
     /**
      * Ein Skill ist ein Verzeichnis. Dateien wie .DS_Store zählen nicht als fremder Eintrag,
-     * ebenso wenig ein Symlink, der auf keine Verzeichnis zeigt.
+     * ebenso wenig ein Symlink, der auf kein Verzeichnis zeigt.
      */
-    async istVerzeichnis(verzeichnis, name) {
-        const pfad = path.join(verzeichnis, name);
-        const info = await lstat(pfad).catch(() => undefined);
-        if (info === undefined)
-            return false;
-        if (info.isDirectory())
-            return true;
-        if (!info.isSymbolicLink())
-            return false;
-        return (await stat(pfad).catch(() => undefined))?.isDirectory() === true;
+    istVerzeichnis(info) {
+        return info !== undefined && info.istVerzeichnis;
     }
     async eintraege(ziel, verzeichnis) {
-        const namen = await readdir(verzeichnis).catch(() => []);
+        const zugriff = this.zugriffFuer(ziel);
+        const namen = await zugriff.namen(verzeichnis);
         const ergebnis = [];
-        for (const name of namen.sort()) {
-            if (!(await this.istVerzeichnis(verzeichnis, name)))
+        for (const name of [...namen].sort()) {
+            const pfad = zugriff.verbinden(verzeichnis, name);
+            if (!this.istVerzeichnis(await zugriff.info(pfad)))
                 continue;
-            const zielPfad = await this.linkZiel(verzeichnis, name);
+            const zielPfad = await zugriff.linkZiel(pfad);
             const gedeutet = zielPfad ? await this.deuten(zielPfad) : undefined;
             if (gedeutet?.art === 'link')
                 ergebnis.push({ art: 'link', link: { ziel, name, checkout: gedeutet.checkout, skill: gedeutet.skill } });
@@ -148,20 +181,21 @@ export class DateisystemZiele {
         return ergebnis;
     }
     async linkLegen(ziel, verzeichnis, name, checkout, skill, ersetzen) {
+        const zugriff = this.zugriffFuer(ziel);
         // 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))
+        // `verbinden` fiele auf das Zielverzeichnis selbst zurück, und `ersetzen` löschte es (E12, E32).
+        if (name.length === 0 || name.includes('/') || name.includes(zugriff.trenner))
             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);
+        await zugriff.verzeichnisAnlegen(verzeichnis);
+        const pfad = zugriff.verbinden(verzeichnis, name);
+        const info = await zugriff.info(pfad);
         if (info) {
-            const zielPfad = await this.linkZiel(verzeichnis, name);
+            const zielPfad = await zugriff.linkZiel(pfad);
             const eigen = zielPfad ? await this.deuten(zielPfad) : undefined;
             if (eigen)
-                await unlink(pfad);
+                await zugriff.linkEntfernen(pfad);
             else if (ersetzen)
-                await rm(pfad, { recursive: true, force: true });
+                await zugriff.loeschen(pfad);
             else
                 throw new NameBelegt(ziel, name);
         }
@@ -171,33 +205,36 @@ export class DateisystemZiele {
         // relativer Pfad. `path.resolve` kostet nichts und macht die Zusage hier fest.
         const checkoutZiel = path.resolve(checkout.pfad, skill.pfad);
         try {
-            await symlink(checkoutZiel, pfad, symlinkTyp());
+            await zugriff.linkAnlegen(pfad, checkoutZiel);
         }
         catch (ursache) {
             throw new LinkAnlegenFehlgeschlagen(pfad, checkoutZiel, ursache instanceof Error ? ursache.message : String(ursache), linkFehlerHinweis());
         }
     }
-    async linkEntfernen(_ziel, verzeichnis, name) {
-        const zielPfad = await this.linkZiel(verzeichnis, name);
+    async linkEntfernen(ziel, verzeichnis, name) {
+        const zugriff = this.zugriffFuer(ziel);
+        const pfad = zugriff.verbinden(verzeichnis, name);
+        const zielPfad = await zugriff.linkZiel(pfad);
         if (!zielPfad)
             return;
         if (await this.deuten(zielPfad))
-            await unlink(path.join(verzeichnis, name));
+            await zugriff.linkEntfernen(pfad);
     }
     /**
      * 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);
+    async eintragLoeschen(ziel, verzeichnis, name) {
+        const zugriff = this.zugriffFuer(ziel);
+        const pfad = zugriff.verbinden(verzeichnis, name);
+        const info = await zugriff.info(pfad);
         if (info === undefined)
             return;
-        if (info.isSymbolicLink())
-            await unlink(pfad);
+        if (info.istLink)
+            await zugriff.linkEntfernen(pfad);
         else
-            await rm(pfad, { recursive: true, force: true });
+            await zugriff.loeschen(pfad);
     }
     /**
      * Lockfile-Kandidaten in Suchreihenfolge (E50): zuerst $XDG_STATE_HOME/skills/.skill-lock.json,
@@ -235,6 +272,11 @@ export class DateisystemZiele {
         }
     }
     /**
+     * Lockfile und Ordner-Hash lesen immer lokal, nie über die Bridge (E78): beide gehören zur
+     * Übernahme-Erkennung eines agents-Ziels (E48 b), und zusätzliche Homedirs gibt es bisher nur bei
+     * claude-code. Käme das je zusammen, wäre der Ordner-Hash über die Bridge außerdem ein Lesen
+     * jeder Datei einzeln — dann lieber ein eigener Schnitt als ein stiller Sonderweg hier.
+     *
      * 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

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";
@@ -253,6 +254,55 @@ export class GitQuellen {
             })),
         };
     }
+    /**
+     * 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];
@@ -374,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