hmgr 0.0.6 → 0.0.7

package/dist/gui/renderer/styles.css

@@ -695,6 +695,26 @@ dialog::backdrop{background:rgba(9,45,37,.62)}
 /* Wo ein Eintrag steht (E64): kein margin-left:auto, sonst teilte er sich den freien Platz mit dem
    Übernehmen-Knopf und stünde in der Mitte statt beim Text. */
 .mcpkartezeilen .geteiltvermerk{font-size:16px;color:var(--tinte-leise)}
+/* Bundle-Gruppe an der Ziel-Karte (E69, F68): eine Einheit über ihren Skill-Zeilen, sichtbar
+   zusammengefasst durch eine linke Kante statt durch einen eigenen Kasten — die Zeilen darin sind
+   dieselbe Tabelle wie darunter und sollen mit ihr fluchten. */
+.bundlegruppe{margin:14px 0;border-left:3px solid var(--emaille-tief);padding-left:12px}
+.bundlekopf{display:flex;flex-wrap:wrap;align-items:center;gap:5px 14px;padding-bottom:8px}
+.bundletitel{display:inline-flex;align-items:center;gap:8px}
+.bundlename{font-family:var(--schrift);font-weight:700;font-size:17px;letter-spacing:-.012em}
+.bundlequelle{font-size:16px;color:var(--tinte-weich)}
+.bundlezahl{font-size:16px;color:var(--tinte-leise)}
+.bundlemitglieder{font-family:var(--mono);font-size:16px;letter-spacing:-.012em;color:var(--tinte-weich)}
+.bundlekopf .knopf{margin-left:auto}
+.bundlegruppe .linkliste li:last-child{border-bottom:1px solid var(--strich-zart)}
+
+/* Bundle- und Skill-Sektion im Dialog „Skills hinzufügen" (E69): zwei benannte Gruppen unter
+   demselben Suchfeld. */
+.dskgruppe + .dskgruppe{margin-top:18px}
+.dskgruppe > .etikett{display:block;margin-bottom:9px}
+.dskgruppentext{margin:0 0 10px;color:var(--tinte-weich)}
+.dskgruppenfehler{margin:10px 0 0;color:var(--messing-satt);white-space:pre-line}
+
 /* Leerer Katalog: keine Aktion, sondern der Weg zur Datei. */
 .startfeld.mcpstart{display:block}
 .startfeld.mcpstart p{max-width:62ch}

package/dist/kern/anwendungsfaelle.js

@@ -1,6 +1,6 @@
 // Anwendungsfälle. Pfade werden hier nur als Zeichenketten normalisiert, gelesen wird über die Ports.
 import path from 'node:path';
-import { AbhaengigkeitFehlt, EinschraenkungOhneZeiger, FremderEintragUnbekannt, HarnessNichtVorhanden, HarnessTypUnbekannt, KeinPassenderRef, McpEbeneNichtUnterstuetzt, McpFaehigkeitFehlt, McpUebernahmeNichtMoeglich, McpUnbekannt, OrtNichtUnterstuetzt, PluginMehrdeutig, PluginUnbekannt, QuelleAufraeumenLokaleAenderungen, QuelleNameBelegt, QuelleUnbekannt, SkillMehrdeutig, SkillOrdnerBereitsVerwaltet, SkillOrdnerFaehigkeitFehlt, SkillOrdnerNichtVerwaltet, SkillUnbekannt, ZeigerMehrdeutig, ZeigerSchreibenGesperrt, marketplaceUrl, pluginSchluessel, pluginSchluesselZerlegen, quelleAlsText, quelleMitNamen, quelleName, quelleNameAbleiten, quelleNameFrei, quelleSchluessel, zielSchluessel, } from "./modell.js";
+import { AbhaengigkeitFehlt, BundleMehrdeutig, BundleMitgliederFehlen, BundleNamenskonflikte, BundleNichtInstalliert, BundleUnbekannt, EinschraenkungOhneZeiger, FremderEintragUnbekannt, HarnessNichtVorhanden, HarnessTypUnbekannt, KeinPassenderRef, McpEbeneNichtUnterstuetzt, McpFaehigkeitFehlt, McpUebernahmeNichtMoeglich, McpUnbekannt, OrtNichtUnterstuetzt, PluginMehrdeutig, PluginUnbekannt, QuelleAufraeumenLokaleAenderungen, QuelleNameBelegt, QuelleUnbekannt, SkillMehrdeutig, SkillOrdnerBereitsVerwaltet, SkillOrdnerFaehigkeitFehlt, SkillOrdnerNichtVerwaltet, SkillUnbekannt, ZeigerMehrdeutig, ZeigerSchreibenGesperrt, bundleSchluessel, marketplaceUrl, pluginSchluessel, pluginSchluesselZerlegen, quelleAlsText, quelleMitNamen, quelleName, quelleNameAbleiten, quelleNameFrei, quelleSchluessel, zielSchluessel, } from "./modell.js";
 import { passenderRef } from "./version.js";
 import { kannIstRegistriert, kannMcp, kannPlugins, kannProfile, kannSkillOrdner, kannZurueckbauen, } from "../ports/harness.js";
 /**
@@ -364,6 +364,10 @@ export class Anwendungsfaelle {
             for (const pfad of zustand.arbeitsverzeichnisse)
                 ziele.push(arbeitsverzeichnisZiel(harness.name, pfad));
         const zielErgebnisse = [];
+        // Mit den Links verschwinden auch die Bundle-Verweise dieser Ziele (E69): ein Verweis auf Links,
+        // die es nicht mehr gibt, wäre ein Rest, den niemand mehr sieht.
+        const nachZustand = await this.p.zustand.lesen();
+        let bundlesGeaendert = false;
         for (const ziel of ziele) {
             const verzeichnis = harness.zielVerzeichnis(ziel.ort);
             const eintraege = await this.p.ziele.eintraege(ziel, verzeichnis).catch(() => []);
@@ -375,9 +379,13 @@ export class Anwendungsfaelle {
                 await this.p.ziele.linkEntfernen(ziel, verzeichnis, name);
                 entfernteLinks.push(name);
             }
+            if (Anwendungsfaelle.bundlesZerbrechen(nachZustand, ziel, entfernteLinks).length > 0)
+                bundlesGeaendert = true;
             const konfigurationZurueckgebaut = kannZurueckbauen(harness) ? await harness.zurueckbauen(ziel.ort) : false;
             zielErgebnisse.push({ ziel, entfernteLinks, konfigurationZurueckgebaut });
         }
+        if (bundlesGeaendert)
+            await this.p.zustand.schreiben(nachZustand);
         return { harness: harness.name, ziele: zielErgebnisse };
     }
     /**
@@ -513,6 +521,15 @@ export class Anwendungsfaelle {
             throw new QuelleAufraeumenLokaleAenderungen(inventar.checkoutsMitLokalenAenderungen);
         for (const link of inventar.links)
             await this.p.ziele.linkEntfernen(link.ziel, link.verzeichnis, link.name);
+        // Wo dabei ein Bundle-Mitglied fiel, zerbricht das Bundle in diesem Ziel (E69), wie beim
+        // einzelnen `linkEntfernen`: die übrigen Links bleiben als Einzel-Installationen liegen.
+        const zustand = await this.p.zustand.lesen();
+        let bundlesGeaendert = false;
+        for (const link of inventar.links)
+            if (Anwendungsfaelle.bundlesZerbrechen(zustand, link.ziel, [link.name]).length > 0)
+                bundlesGeaendert = true;
+        if (bundlesGeaendert)
+            await this.p.zustand.schreiben(zustand);
         for (const checkout of inventar.checkouts)
             await this.p.quellen.entfernen(checkout);
         return { entfernteLinks: inventar.links.length, entfernteCheckouts: inventar.checkouts.length };
@@ -551,7 +568,20 @@ export class Anwendungsfaelle {
             try {
                 const ref = await this.p.quellen.standardRef(quelle);
                 const skills = await this.p.quellen.skills(quelle, ref);
-                ergebnis.push({ quelle, ref, skills });
+                // Änderungsdatum je Skill (E70, F70=O1), in einem Aufruf für die ganze Quelle. Ein
+                // Fehlschlag kostet nur die Daten, nicht den Katalog: der Reiter zeigt dann die Skills
+                // ohne Zusatzangabe.
+                const daten = await this.p.quellen
+                    .letzteAenderungen(quelle, ref, skills.map((s) => s.pfad))
+                    .catch(() => new Map());
+                ergebnis.push({
+                    quelle,
+                    ref,
+                    skills: skills.map((skill) => {
+                        const geaendert = daten.get(skill.pfad);
+                        return geaendert === undefined ? skill : { ...skill, geaendert };
+                    }),
+                });
             }
             catch (fehler) {
                 ergebnis.push({ quelle, skills: [], fehler: fehlertext(fehler) });
@@ -630,6 +660,359 @@ export class Anwendungsfaelle {
         }
         return skills;
     }
+    /**
+     * Bundle-Katalog (E69): je bekannter Quelle ihre Bundle-Definitionen am Standard-Ref. Bundles
+     * sind Quell-Inhalt und werden beim Quellen-Scan entdeckt, es gibt keinen eigenen Katalog und
+     * keinen Pflegebefehl (F68). Eine nicht erreichbare Quelle bekommt einen Fehlervermerk, statt den
+     * Lauf abzubrechen, wie bei `katalog` und `marketplaces`.
+     */
+    async bundleKatalog() {
+        const zustand = await this.p.zustand.lesen();
+        const ergebnis = [];
+        for (const quelle of zustand.quellen) {
+            try {
+                const ref = await this.p.quellen.standardRef(quelle);
+                const funde = await this.p.quellen.bundles(quelle, ref);
+                ergebnis.push({
+                    quelle,
+                    ref,
+                    bundles: funde.flatMap((f) => (f.art === 'bundle' ? [f.bundle] : [])),
+                    kaputte: funde.flatMap((f) => (f.art === 'fehler' ? [{ datei: f.datei, fehler: f.fehler }] : [])),
+                });
+            }
+            catch (fehler) {
+                ergebnis.push({ quelle, bundles: [], kaputte: [], fehler: fehlertext(fehler) });
+            }
+        }
+        return ergebnis;
+    }
+    /**
+     * Bundle über alle bekannten Quellen suchen (E69). Mehrere Treffer sind nur mit Quellenhinweis
+     * erlaubt, dieselbe Regel wie bei Skills (E12). Eine nicht erreichbare Quelle fällt aus der Suche,
+     * statt sie abzubrechen — sonst fände kein einziges Bundle mehr statt, weil eine Quelle klemmt.
+     */
+    async bundleFinden(name, quelleHinweis) {
+        const funde = [];
+        for (const eintrag of await this.bundleKatalog()) {
+            if (!quellePasst(eintrag.quelle, quelleHinweis))
+                continue;
+            for (const bundle of eintrag.bundles)
+                if (bundle.name === name)
+                    funde.push(bundle);
+        }
+        if (funde.length === 0)
+            throw new BundleUnbekannt(name);
+        if (funde.length > 1)
+            throw new BundleMehrdeutig(name, funde.map((b) => b.quelle));
+        return funde[0];
+    }
+    /** Die Definition zu einer Installation, aus der Quelle, in der sie steht (E69, für den Abgleich). */
+    async bundleAusQuelle(name, quelle) {
+        const key = quelleSchluessel(quelle);
+        const gefuehrt = (await this.p.zustand.lesen()).quellen.find((q) => quelleSchluessel(q) === key);
+        if (gefuehrt === undefined)
+            throw new QuelleUnbekannt(quelle);
+        const ref = await this.p.quellen.standardRef(gefuehrt);
+        for (const fund of await this.p.quellen.bundles(gefuehrt, ref))
+            if (fund.art === 'bundle' && fund.bundle.name === name)
+                return fund.bundle;
+        throw new BundleUnbekannt(name);
+    }
+    /**
+     * Mitglieder einer Definition auflösen (E69, F66): je Mitglied die Quelle (die geführte, wenn hmgr
+     * sie schon kennt, sonst die Adresse aus der Definition), ihren Standard-Ref und den Skill am
+     * genannten Pfad. Schreibt nichts: eine noch unbekannte Quelle wird hier nur gelesen und kommt
+     * erst in den Zustand, wenn das ganze Bundle steht (F66b, alles oder nichts). Lässt sich ein
+     * Mitglied nicht auflösen, wirft der Aufruf mit allen Gründen auf einmal.
+     */
+    async bundleAufloesen(bundle) {
+        const zustand = await this.p.zustand.lesen();
+        const gefuehrt = new Map(zustand.quellen.map((q) => [quelleSchluessel(q), q]));
+        const funde = [];
+        const neue = [];
+        const fehler = [];
+        for (const mitglied of bundle.mitglieder) {
+            const key = quelleSchluessel(mitglied.quelle);
+            const quelle = gefuehrt.get(key) ?? neue.find((q) => quelleSchluessel(q) === key) ?? mitglied.quelle;
+            const adresse = quelleAlsText(mitglied.quelle);
+            try {
+                const ref = await this.p.quellen.standardRef(quelle);
+                const skill = (await this.p.quellen.skills(quelle, ref)).find((s) => s.pfad === mitglied.pfad);
+                if (skill === undefined) {
+                    fehler.push({ adresse, pfad: mitglied.pfad, grund: 'kein Skill an diesem Pfad' });
+                    continue;
+                }
+                funde.push({ quelle, ref, skill });
+                if (!gefuehrt.has(key) && !neue.some((q) => quelleSchluessel(q) === key))
+                    neue.push(quelle);
+            }
+            catch (f) {
+                fehler.push({ adresse, pfad: mitglied.pfad, grund: fehlertext(f) });
+            }
+        }
+        if (fehler.length > 0)
+            throw new BundleMitgliederFehlen(bundle.name, fehler);
+        return { funde, neue };
+    }
+    /** Ziel einer Bundle-Installation aus dem Zustand (E69). */
+    static installationZiel(installation) {
+        return { harness: installation.harness, ort: installation.ort };
+    }
+    /** Bundle-Installationen eines Ziels aus dem Zustand (E69). */
+    static installationenAn(zustand, ziel) {
+        const schluessel = zielSchluessel(ziel);
+        return zustand.bundleInstallationen.filter((i) => zielSchluessel(Anwendungsfaelle.installationZiel(i)) === schluessel);
+    }
+    /**
+     * Namenskonflikte am Ziel (E69, F67): Liegt dort schon derselbe Skill aus derselben Quelle als
+     * hmgr-Link, wird er als Mitglied übernommen — so wird aus Bestand ein Bundle, ohne erst Links von
+     * Hand zu entfernen. Alles andere ist ein Konflikt: ein anderer Skill gleichen Namens, ein fremder
+     * Eintrag, ein Link ohne bekannte Quelle, ein Link, der schon zu einem anderen Bundle gehört (den
+     * zu übernehmen zerbräche jenes, ohne dass es jemand sagt), und zwei Mitglieder desselben Bundles
+     * mit demselben Namen (am Ziel gibt es den Namen nur einmal, E12).
+     */
+    async bundleKonflikte(bundle, ziel, verzeichnis, funde) {
+        const eintraege = await this.p.ziele.eintraege(ziel, verzeichnis).catch(() => []);
+        const nachName = new Map();
+        for (const eintrag of eintraege)
+            nachName.set(eintrag.art === 'link' ? eintrag.link.name : eintrag.name, eintrag);
+        const zustand = await this.p.zustand.lesen();
+        const eigenerSchluessel = bundleSchluessel(bundle);
+        const fremdesBundle = new Map();
+        for (const installation of Anwendungsfaelle.installationenAn(zustand, ziel)) {
+            if (bundleSchluessel({ name: installation.bundle, quelle: installation.quelle }) === eigenerSchluessel)
+                continue;
+            for (const name of installation.skills)
+                fremdesBundle.set(name, installation.bundle);
+        }
+        const konflikte = [];
+        const uebernommen = [];
+        const gesehen = new Set();
+        for (const fund of funde) {
+            const name = fund.skill.name;
+            if (gesehen.has(name)) {
+                konflikte.push({ name, grund: 'das Bundle nennt zwei Skills dieses Namens, am Ziel gibt es ihn nur einmal' });
+                continue;
+            }
+            gesehen.add(name);
+            const eintrag = nachName.get(name);
+            if (eintrag === undefined)
+                continue;
+            if (eintrag.art === 'fremd') {
+                konflikte.push({ name, grund: 'dort liegt ein fremder Eintrag' });
+                continue;
+            }
+            if (eintrag.art === 'link-ohne-quelle') {
+                konflikte.push({ name, grund: 'dort liegt ein Link, dessen Quelle hmgr nicht kennt' });
+                continue;
+            }
+            const gleicheQuelle = quelleSchluessel(eintrag.link.checkout.quelle) === quelleSchluessel(fund.quelle);
+            if (!gleicheQuelle || eintrag.link.skill.pfad !== fund.skill.pfad) {
+                konflikte.push({
+                    name,
+                    grund: `dort liegt schon ein Link aus ${quelleAlsText(eintrag.link.checkout.quelle)} (${eintrag.link.skill.pfad})`,
+                });
+                continue;
+            }
+            const anderes = fremdesBundle.get(name);
+            if (anderes !== undefined) {
+                konflikte.push({ name, grund: `der Link gehört zum Bundle „${anderes}"` });
+                continue;
+            }
+            uebernommen.push(name);
+        }
+        return { konflikte, uebernommen };
+    }
+    /**
+     * Quellen aus einer Bundle-Definition anlegen (E69, F66), nachdem alles geprüft ist. Der
+     * Anzeigename ist der abgeleitete, bei Kollision der nächste freie (dieselbe Regel wie bei der
+     * Übernahme, E31): hier nennt niemand einen Namen, und ein Abbruch am Anzeigenamen wäre die
+     * falsche Sorte Hürde.
+     */
+    async bundleQuellenAnlegen(neue) {
+        const angelegt = [];
+        for (const quelle of neue) {
+            const zustand = await this.p.zustand.lesen();
+            const key = quelleSchluessel(quelle);
+            if (zustand.quellen.some((q) => quelleSchluessel(q) === key))
+                continue;
+            const name = quelleNameFrei(quelleNameAbleiten(quelle), zustand.quellen);
+            const { quelle: gefuehrt } = await this.quelleHinzufuegen(quelle, name);
+            angelegt.push(gefuehrt);
+        }
+        return angelegt;
+    }
+    /** Die Zugehörigkeit der Links eines Bundles im Ziel merken (E69), einen alten Eintrag ersetzend. */
+    async bundleInstallationMerken(ziel, bundle, skills) {
+        const zustand = await this.p.zustand.lesen();
+        const schluessel = zielSchluessel(ziel);
+        const eigener = bundleSchluessel(bundle);
+        zustand.bundleInstallationen = zustand.bundleInstallationen.filter((i) => zielSchluessel(Anwendungsfaelle.installationZiel(i)) !== schluessel ||
+            bundleSchluessel({ name: i.bundle, quelle: i.quelle }) !== eigener);
+        zustand.bundleInstallationen.push({
+            harness: ziel.harness,
+            ort: ziel.ort,
+            bundle: bundle.name,
+            quelle: bundle.quelle,
+            skills,
+        });
+        await this.p.zustand.schreiben(zustand);
+    }
+    /**
+     * Zerbrechen (E69): Wird ein einzelner Link entfernt, der zu einem Bundle gehört, zerbricht das
+     * Bundle in diesem Ziel — die übrigen Links werden Einzel-Installationen, der Bundle-Verweis
+     * fällt weg. Ändert nur den übergebenen Zustand, geschrieben wird er vom Aufrufer, der ohnehin
+     * schreibt. Gibt die Namen der zerbrochenen Bundles zurück, damit die Oberfläche es sagen kann.
+     */
+    static bundlesZerbrechen(zustand, ziel, namen) {
+        const schluessel = zielSchluessel(ziel);
+        const zerbrochen = [];
+        zustand.bundleInstallationen = zustand.bundleInstallationen.filter((installation) => {
+            if (zielSchluessel(Anwendungsfaelle.installationZiel(installation)) !== schluessel)
+                return true;
+            if (!installation.skills.some((name) => namen.includes(name)))
+                return true;
+            zerbrochen.push(installation.bundle);
+            return false;
+        });
+        return zerbrochen;
+    }
+    /**
+     * Bundle installieren (E69): das Bundle als Ganzes in ein Ziel. Erst wird alles geprüft — jedes
+     * Mitglied auflösbar (F66b), kein Namenskonflikt am Ziel (F67) —, dann werden fehlende Quellen
+     * angelegt und die Links gelegt. Scheitert die Prüfung, ist nichts geschehen: weder ein Link noch
+     * ein Eintrag im Zustand, denn ein halbes Bundle wäre stilles Fehlen von Skills (B13).
+     *
+     * Der Zeiger bleibt außen vor: Bundles stehen im Zustand, nicht in der composer.json (E69), also
+     * legt der Aufruf seine Links wie mit `--local` und trifft die Sperre aus E57 nie.
+     */
+    async bundleInstallieren(args) {
+        const harness = await this.harnessGeprueft(args.ziel.harness);
+        if (!harness.orte().includes(args.ziel.ort.art))
+            throw new OrtNichtUnterstuetzt(harness.name, args.ziel.ort.art);
+        const bundle = await this.bundleFinden(args.bundle, args.quelle);
+        const { funde, neue } = await this.bundleAufloesen(bundle);
+        const verzeichnis = harness.zielVerzeichnis(args.ziel.ort);
+        const { konflikte, uebernommen } = await this.bundleKonflikte(bundle, args.ziel, verzeichnis, funde);
+        if (konflikte.length > 0)
+            throw new BundleNamenskonflikte(bundle.name, args.ziel, konflikte);
+        const neueQuellen = await this.bundleQuellenAnlegen(neue);
+        for (const fund of funde)
+            await this.linkAnlegen(harness, args.ziel, fund);
+        const namen = funde.map((f) => f.skill.name);
+        await this.bundleInstallationMerken(args.ziel, bundle, namen);
+        // Der Hinweis des Harness gilt dem Ort, also einmal für das ganze Bundle, nicht je Skill (E34).
+        const hinweis = await this.harnessHinweis(harness, args.ziel.ort);
+        return {
+            bundle,
+            ziel: args.ziel,
+            gelegt: namen.filter((n) => !uebernommen.includes(n)),
+            uebernommen,
+            neueQuellen,
+            ...(hinweis === undefined ? {} : { hinweis }),
+        };
+    }
+    /** Die Installation eines Bundles in einem Ziel, über seinen Namen (E69). */
+    async installationFinden(bundleName, ziel) {
+        const zustand = await this.p.zustand.lesen();
+        const treffer = Anwendungsfaelle.installationenAn(zustand, ziel).filter((i) => i.bundle === bundleName);
+        if (treffer.length === 0)
+            throw new BundleNichtInstalliert(bundleName, ziel);
+        // Zwei Quellen dürfen denselben Bundle-Namen führen (E69); sind beide hier installiert, muss
+        // die Quelle genannt werden, wie bei einem mehrdeutigen Skill-Namen (E12).
+        if (treffer.length > 1)
+            throw new BundleMehrdeutig(bundleName, treffer.map((i) => i.quelle));
+        return treffer[0];
+    }
+    /**
+     * Bundle entfernen (E69): alle seine Links im Ziel und den Bundle-Verweis. Entfernt wird direkt
+     * über den Ziele-Port, nicht über den Anwendungsfall `linkEntfernen` — der macht Zeiger-Arbeit
+     * (E57) und ließe das Bundle bei jedem einzelnen Link zerbrechen, das es hier gerade verlässt.
+     */
+    async bundleEntfernen(args) {
+        const harness = await this.harnessGeprueft(args.ziel.harness);
+        const installation = await this.installationFinden(args.bundle, args.ziel);
+        const verzeichnis = harness.zielVerzeichnis(args.ziel.ort);
+        const eintraege = await this.p.ziele.eintraege(args.ziel, verzeichnis).catch(() => []);
+        const eigene = new Set(eintraege.filter((e) => e.art !== 'fremd').map((e) => (e.art === 'link' ? e.link.name : e.name)));
+        const entfernt = [];
+        for (const name of installation.skills) {
+            // Was nicht mehr liegt, wird nicht gemeldet: ein von Hand gelöschter Link ist kein Fehler.
+            if (!eigene.has(name))
+                continue;
+            await this.p.ziele.linkEntfernen(args.ziel, verzeichnis, name);
+            entfernt.push(name);
+        }
+        const zustand = await this.p.zustand.lesen();
+        const schluessel = zielSchluessel(args.ziel);
+        const eigenerSchluessel = bundleSchluessel({ name: installation.bundle, quelle: installation.quelle });
+        zustand.bundleInstallationen = zustand.bundleInstallationen.filter((i) => zielSchluessel(Anwendungsfaelle.installationZiel(i)) !== schluessel ||
+            bundleSchluessel({ name: i.bundle, quelle: i.quelle }) !== eigenerSchluessel);
+        await this.p.zustand.schreiben(zustand);
+        return { bundle: installation.bundle, quelle: installation.quelle, ziel: args.ziel, entfernt };
+    }
+    /**
+     * Bundle-Abgleich (E69): jedes installierte Bundle gegen seine Definition ziehen — neue Mitglieder
+     * verlinken, entfallene Links wegnehmen, bestehende auf den aktuellen Stand ihrer Quelle legen.
+     * Wirkt auf das Bundle als Ganzes: Lässt sich eine Definitionsänderung nicht vollständig nachziehen
+     * (Quelle weg, Pfad kein Skill mehr, Namenskonflikt), bleibt das Bundle im betroffenen Ziel auf dem
+     * alten Stand und der Lauf meldet es, statt es halb nachzuziehen (F66b).
+     */
+    async bundleAbgleich(args) {
+        const zustand = await this.p.zustand.lesen();
+        const zielSchl = args?.ziel === undefined ? undefined : zielSchluessel(args.ziel);
+        const installationen = zustand.bundleInstallationen.filter((i) => (args?.bundle === undefined || i.bundle === args.bundle) &&
+            (zielSchl === undefined || zielSchluessel(Anwendungsfaelle.installationZiel(i)) === zielSchl));
+        const ergebnis = [];
+        for (const installation of installationen) {
+            const ziel = Anwendungsfaelle.installationZiel(installation);
+            const kopf = { ziel, bundle: installation.bundle, quelle: installation.quelle };
+            try {
+                const harness = await this.harnessGeprueft(ziel.harness);
+                // Die Definition liegt in der Quelle: ohne Nachziehen bliebe eine Änderung unsichtbar,
+                // dieselbe Vorsorge wie bei einer Versionseinschränkung (E33). Einmal je Lauf und Quelle,
+                // ein Fehlschlag (kein Netz) arbeitet mit dem vorhandenen Stand weiter.
+                await this.refsNachziehen(installation.quelle);
+                const bundle = await this.bundleAusQuelle(installation.bundle, installation.quelle);
+                const { funde, neue } = await this.bundleAufloesen(bundle);
+                const verzeichnis = harness.zielVerzeichnis(ziel.ort);
+                const { konflikte } = await this.bundleKonflikte(bundle, ziel, verzeichnis, funde);
+                if (konflikte.length > 0)
+                    throw new BundleNamenskonflikte(bundle.name, ziel, konflikte);
+                const neueQuellen = await this.bundleQuellenAnlegen(neue);
+                for (const fund of funde)
+                    await this.linkAnlegen(harness, ziel, fund);
+                const namen = funde.map((f) => f.skill.name);
+                const entfernt = [];
+                for (const name of installation.skills) {
+                    if (namen.includes(name))
+                        continue;
+                    await this.p.ziele.linkEntfernen(ziel, verzeichnis, name);
+                    entfernt.push(name);
+                }
+                await this.bundleInstallationMerken(ziel, bundle, namen);
+                const gelegt = namen.filter((n) => !installation.skills.includes(n));
+                ergebnis.push({
+                    ...kopf,
+                    ergebnis: gelegt.length === 0 && entfernt.length === 0 ? 'unveraendert' : 'aktualisiert',
+                    gelegt,
+                    entfernt,
+                    neueQuellen,
+                });
+            }
+            catch (fehler) {
+                ergebnis.push({
+                    ...kopf,
+                    ergebnis: 'fehlgeschlagen',
+                    gelegt: [],
+                    entfernt: [],
+                    neueQuellen: [],
+                    fehler: fehlertext(fehler),
+                });
+            }
+        }
+        return ergebnis;
+    }
     /**
      * Arbeitsverzeichnis hinzufügen (E21, E26): Zeiger suchen, Bindung je vorhandenem Harness merken.
      * Kein Zeiger heißt: Verzeichnis merken, keine Bindung, Hinweis. Mehrdeutig heißt: Fehler,
@@ -849,28 +1232,36 @@ export class Anwendungsfaelle {
     /**
      * Link entfernen. Ohne `lokal` verschwindet der Skill auch aus dem Zeiger (E17). Mit `lokal` an
      * einem gebundenen Ziel bleibt der Zeiger unangetastet, ein Hinweis sagt das (E57, F32).
+     *
+     * Gehörte der Link zu einem Bundle, zerbricht es in diesem Ziel (E69): die übrigen Links bleiben
+     * als Einzel-Installationen liegen, der Bundle-Verweis fällt weg. `zerbrochen` nennt die Bundles,
+     * damit die Oberfläche es sagen kann.
      */
     async linkEntfernen(args) {
         const harness = await this.harnessGeprueft(args.ziel.harness);
         // Vor jeder Wirkung: kein Entfernen, wenn danach das Schreiben in den Zeiger scheitern würde (E57).
         await this.zeigerSchreibenPruefen(args.ziel, args.lokal);
         await this.p.ziele.linkEntfernen(args.ziel, harness.zielVerzeichnis(args.ziel.ort), args.skill);
+        const zustand = await this.p.zustand.lesen();
+        const zerbrochen = Anwendungsfaelle.bundlesZerbrechen(zustand, args.ziel, [args.skill]);
+        if (zerbrochen.length > 0)
+            await this.p.zustand.schreiben(zustand);
         if (args.lokal === true && args.ziel.ort.art === 'arbeitsverzeichnis') {
             const zeigerPfad = await this.bindungFinden(args.ziel);
             if (zeigerPfad !== undefined)
-                return { hinweis: 'Der Link ist nur lokal entfernt, der Zeiger bleibt unangetastet (F32).' };
-            return {};
+                return { hinweis: 'Der Link ist nur lokal entfernt, der Zeiger bleibt unangetastet (F32).', zerbrochen };
+            return { zerbrochen };
         }
         if (args.lokal === true || args.ziel.ort.art !== 'arbeitsverzeichnis')
-            return {};
+            return { zerbrochen };
         const zeigerPfad = await this.bindungFinden(args.ziel);
         if (zeigerPfad === undefined)
-            return {};
+            return { zerbrochen };
         const zeiger = await this.p.zeiger.lesen(zeigerPfad);
         if (!zeiger.skills.delete(args.skill))
-            return {};
+            return { zerbrochen };
         await this.p.zeiger.schreiben(zeigerPfad, zeiger);
-        return {};
+        return { zerbrochen };
     }
     /**
      * Ignoriert einen fremden Eintrag (E43): idempotent, kein Duplikat. Gleichheit über harness, Ort
@@ -1211,7 +1602,14 @@ export class Anwendungsfaelle {
             checkouts.push({
                 checkout: { ...checkout, quelle: quelleMitNamen(checkout.quelle, gefuehrt.name) },
                 aktualisierung,
+                geaenderteSkills: await this.geaenderteSkills(checkout, aktualisierung),
             });
+            // `aktualisieren` holt für einen Checkout dieselben Refs wie `refsNachziehen` (fetch auf dem
+            // Basis-Clone). Ist das gelaufen, braucht der Bundle-Abgleich unten die Quelle nicht ein
+            // zweites Mal zu holen. Ein übersprungener oder gescheiterter Checkout hat nichts geholt und
+            // wird deshalb nicht vermerkt.
+            if (aktualisierung.ergebnis === 'aktualisiert' || aktualisierung.ergebnis === 'unveraendert')
+                this.nachgezogen.add(quelleSchluessel(checkout.quelle));
         }
         // Nach den Checkouts die Plugins nachziehen (E14).
         const pluginHarnesses = [];
@@ -1221,7 +1619,41 @@ export class Anwendungsfaelle {
             await harness.plugins.aktualisieren();
             pluginHarnesses.push(harness.name);
         }
-        return { checkouts, pluginHarnesses, aufraeumen: await this.verwaisteAufraeumen(checkouts, rueckfragen) };
+        // Bundles vor dem Aufräumen (E69, F64=O1): der Abgleich legt und entfernt Links, und erst
+        // danach steht fest, in welchen Checkout noch ein Link zeigt. Ein Fehlschlag je Bundle steckt
+        // in seinem Eintrag, er bricht den Lauf nicht ab — wie eine unerreichbare Quelle (E51).
+        const bundles = await this.bundleAbgleich();
+        return {
+            checkouts,
+            pluginHarnesses,
+            bundles,
+            aufraeumen: await this.verwaisteAufraeumen(checkouts, rueckfragen),
+        };
+    }
+    /**
+     * Welche Skills ein aktualisierter Checkout mitgebracht hat (E70). Die geänderten Pfade kommen
+     * aus dem Vergleich von altem und neuem Commit, die Skills aus dem Checkout selbst: ein Skill,
+     * der in dieser Quelle liegt, hier aber nicht ausgecheckt ist, geht den Nutzer nichts an. Ein
+     * Skill zählt, wenn eine geänderte Datei in seinem Ordner liegt; ein Wurzel-Skill ist das ganze
+     * Repo und zählt bei jeder Änderung.
+     *
+     * Nur bei `aktualisiert` gibt es zwei Commits zum Vergleichen. Scheitert die Ermittlung, bleibt
+     * die Liste leer: der Bericht wird ungenauer, der Lauf nicht kaputt.
+     */
+    async geaenderteSkills(checkout, aktualisierung) {
+        if (aktualisierung.ergebnis !== 'aktualisiert')
+            return [];
+        const dateien = await this.p.quellen
+            .geaenderteDateien(checkout.quelle, aktualisierung.von, aktualisierung.nach)
+            .catch(() => []);
+        if (dateien.length === 0)
+            return [];
+        const skills = await this.p.quellen.ausgecheckteSkills(checkout).catch(() => []);
+        const namen = new Set();
+        for (const skill of skills)
+            if (dateien.some((datei) => skill.pfad === '' || datei === skill.pfad || datei.startsWith(`${skill.pfad}/`)))
+                namen.add(skill.name);
+        return [...namen].sort((a, b) => a.localeCompare(b, 'de'));
     }
     /**
      * Pfade, in die ein Link zeigt. Gelesen wird wie beim Ist-Zustand (E19): die Ziele der
@@ -1609,6 +2041,14 @@ export class Anwendungsfaelle {
                 for (const ei of eintraege)
                     if (ei.art === 'fremd')
                         uebernahme.set(ei.name, await this.erkennenFremd(harness, verzeichnis, ei, bekannt, true));
+                // Bundles dieses Ziels (E69), rein aus dem Zustand: nur die Mitglieder, die dort auch
+                // wirklich noch liegen — ein von Hand gelöschter Link soll die Gruppe nicht länger führen.
+                const eigeneNamen = new Set(eintraege.filter((ei) => ei.art !== 'fremd').map((ei) => (ei.art === 'link' ? ei.link.name : ei.name)));
+                const bundles = Anwendungsfaelle.installationenAn(zustand, ziel).map((i) => ({
+                    name: i.bundle,
+                    quelle: i.quelle,
+                    skills: i.skills.filter((name) => eigeneNamen.has(name)),
+                }));
                 ergebnis.push({
                     ziel,
                     verzeichnis,
@@ -1617,6 +2057,7 @@ export class Anwendungsfaelle {
                     gruende: await this.gruende(harness, ziel, eintraege, zeiger, marktplatzFunde),
                     ignoriert,
                     uebernahme,
+                    bundles,
                     istRegistriert,
                     kannSkillOrdner: skillOrdnerFaehig,
                     ...(plugins === undefined ? {} : { plugins }),

package/dist/kern/modell.js

@@ -1,5 +1,12 @@
 // Begriffe aus CONTEXT.md. Nur Werte und Regeln, keine Pfade zu Dateien außerhalb des Modells.
 import { ortSchluessel, urlOrt } from "./quelle-ort.js";
+/**
+ * Identität eines Bundles (E69): Quelle der Definition plus Name. Zwei Quellen dürfen denselben
+ * Bundle-Namen führen, mehrdeutig wird es erst beim Suchen, wie bei Skills (E12).
+ */
+export function bundleSchluessel(bundle) {
+    return `${quelleSchluessel(bundle.quelle)}#${bundle.name}`;
+}
 /** Ansprache eines Plugins im Zeiger und gegenüber der claude-CLI: `<plugin>@<marketplace>`. */
 export function pluginSchluessel(plugin) {
     return `${plugin.name}@${plugin.marketplace}`;
@@ -448,6 +455,79 @@ export class McpUebernahmeUnvollstaendig extends Error {
         this.datei = datei;
     }
 }
+/** Ein Bundle-Name, den keine bekannte Quelle führt (E69). */
+export class BundleUnbekannt extends Error {
+    bundleName;
+    constructor(bundleName) {
+        super(`Bundle „${bundleName}" steht in keiner Quelle`);
+        this.bundleName = bundleName;
+    }
+}
+/** Denselben Bundle-Namen führen mehrere Quellen (E69, Regel wie E12 bei Skills). */
+export class BundleMehrdeutig extends Error {
+    bundleName;
+    quellen;
+    constructor(bundleName, quellen) {
+        super(`Bundle „${bundleName}" liegt in mehreren Quellen: ${quellen.map(quelleSchluessel).join(', ')}`);
+        this.bundleName = bundleName;
+        this.quellen = quellen;
+    }
+}
+/**
+ * Die Definition nennt Mitglieder, die sich auf dieser Maschine nicht auflösen lassen (E69, F66b):
+ * eine Quelle ohne Zugriff oder ein Pfad, der in ihr kein Skill ist. Ein halbes Bundle wäre stilles
+ * Fehlen von Skills, die falsche Fehlersorte (B13) — deshalb wird abgebrochen, bevor irgendetwas
+ * verlinkt ist, und bevor eine fehlende Quelle in den Zustand kommt.
+ */
+export class BundleMitgliederFehlen extends Error {
+    bundleName;
+    fehler;
+    constructor(bundleName, fehler) {
+        const zeilen = fehler.map((f) => `  ${f.adresse} (${f.pfad}): ${f.grund}`).join('\n');
+        super(`Bundle „${bundleName}" ist auf dieser Maschine nicht vollständig herstellbar, nichts wurde verlinkt:\n${zeilen}`);
+        this.bundleName = bundleName;
+        this.fehler = fehler;
+    }
+}
+/**
+ * Am Ziel liegt unter dem Namen eines Mitglieds schon etwas anderes (E69, F67): ein anderer Skill
+ * gleichen Namens, ein fremder Eintrag oder ein Link, der zu einem anderen Bundle gehört. Derselbe
+ * Skill aus derselben Quelle ist kein Konflikt, er wird als Mitglied übernommen. Abbruch wie bei
+ * `BundleMitgliederFehlen`, die Meldung listet alle Konflikte.
+ */
+export class BundleNamenskonflikte extends Error {
+    bundleName;
+    ziel;
+    konflikte;
+    constructor(bundleName, ziel, konflikte) {
+        const zeilen = konflikte.map((k) => `  ${k.name}: ${k.grund}`).join('\n');
+        super(`Bundle „${bundleName}" lässt sich in ${zielSchluessel(ziel)} nicht anlegen, nichts wurde verlinkt:\n${zeilen}`);
+        this.bundleName = bundleName;
+        this.ziel = ziel;
+        this.konflikte = konflikte;
+    }
+}
+/** Ein Bundle, das in diesem Ziel nicht installiert ist (E69): Entfernen kennt nur installierte. */
+export class BundleNichtInstalliert extends Error {
+    bundleName;
+    ziel;
+    constructor(bundleName, ziel) {
+        super(`In ${zielSchluessel(ziel)} ist kein Bundle „${bundleName}" installiert`);
+        this.bundleName = bundleName;
+        this.ziel = ziel;
+    }
+}
+/**
+ * Eine Bundle-Definition lässt sich nicht lesen (E69): kaputtes YAML oder ein Feld außerhalb des
+ * dokumentierten Formats. Wie beim MCP-Katalog (E61) mit Datei, Feld und Grund in der Meldung.
+ */
+export class BundleDateiFehler extends Error {
+    datei;
+    constructor(datei, grund) {
+        super(`Bundle-Datei ${datei}: ${grund}`);
+        this.datei = datei;
+    }
+}
 /** Der MCP-Katalog ~/.hmgr/mcp.yaml lässt sich nicht lesen (E61): kaputtes YAML oder falsches Format. */
 export class McpKatalogFehler extends Error {
     pfad;