hmgr 0.0.6 → 0.0.12

package/dist/kern/anwendungsfaelle.js

@@ -1,8 +1,8 @@
 // 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, HarnessInaktiv, HarnessNichtVorhanden, HarnessTypUnbekannt, HeimAdresseUngueltig, HeimBereitsVorhanden, HeimFaehigkeitFehlt, HeimNurUnterWindows, HeimUnbekannt, KeinPassenderRef, McpEbeneNichtUnterstuetzt, McpFaehigkeitFehlt, McpUebernahmeNichtMoeglich, McpUnbekannt, OrtNichtUnterstuetzt, PluginMehrdeutig, PluginUnbekannt, QuelleAufraeumenLokaleAenderungen, QuelleNameBelegt, QuelleUnbekannt, SkillMehrdeutig, SkillOrdnerBereitsVerwaltet, SkillOrdnerFaehigkeitFehlt, SkillOrdnerNichtVerwaltet, SkillUnbekannt, ZeigerMehrdeutig, ZeigerSchreibenGesperrt, bundleSchluessel, heimAdresseAlsText, heimAdresseZerlegen, 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";
+import { kannIstRegistriert, kannMcp, kannPlugins, kannProfile, kannSkillOrdner, kannZurueckbauen, kannZusaetzlicheHeime, } from "../ports/harness.js";
 /**
  * Frage vor dem Löschen, eine für alle Kandidaten (E28). Der Kern formuliert sie fertig, der
  * Adapter stellt sie: Anzahl und Pfade, damit der Nutzer sieht, worüber er entscheidet.
@@ -83,6 +83,19 @@ export class Anwendungsfaelle {
             throw new HarnessNichtVorhanden(name);
         return h;
     }
+    /**
+     * Wächter vor jedem neu angelegten Link (E76): in ein Ziel eines deaktivierten Harness legt hmgr
+     * keinen. Seit E74 zeigt keine Ansicht solche Ziele, der Link wäre unsichtbarer Zustand. Sitzt in
+     * `linkLegen` und `bundleInstallieren`, also vor jeder Wirkung und für CLI wie GUI gleich.
+     * Bewusst nicht in `linkAnlegen`: über den laufen auch Abgleich und Aktualisierung, und die
+     * pflegen bestehende Links weiter, statt neue anzulegen.
+     */
+    async harnessAktivGeprueft(name) {
+        const harness = await this.harnessGeprueft(name);
+        if (!(await this.aktiveHarnesses()).includes(name))
+            throw new HarnessInaktiv(name);
+        return harness;
+    }
     /** Harnesses, die auf dem Rechner liegen. Alle anderen überspringt hmgr. */
     async vorhandeneHarnesses() {
         const ergebnis = [];
@@ -103,6 +116,130 @@ export class Anwendungsfaelle {
     harnessTypen() {
         return this.p.harnesses.map((h) => h.name);
     }
+    /**
+     * Die Home-Ziele eines Harness (E78, F88): das primäre und jedes zusätzliche Homedir, jedes als
+     * eigenständiges Ziel. Eine Stelle für alle Aufzählungen — Status, Säubern, GUI —, damit ein
+     * zusätzliches Homedir nirgends versehentlich fehlt. Ein `wsl:`-Heim im Zustand einer anderen
+     * Plattform lässt der Port weg (Entscheidung 7), hier kommt es dann gar nicht erst an.
+     */
+    homeZiele(harness) {
+        if (!harness.orte().includes('home'))
+            return [];
+        const ziele = [{ harness: harness.name, ort: { art: 'home' } }];
+        if (kannZusaetzlicheHeime(harness))
+            for (const heim of this.p.heime.zusaetzliche(harness.name))
+                ziele.push({ harness: harness.name, ort: { art: 'home', heim: heim.adresse } });
+        return ziele;
+    }
+    /**
+     * Die Homedirs aller Harness-Typen, für `hmgr harness home` und die GUI (E78). Unabhängig davon,
+     * ob der Harness aktiv oder installiert ist: die Einstellung gehört dem Nutzer, nicht dem Ist-Zustand.
+     */
+    async harnessHeime() {
+        const zustand = await this.p.zustand.lesen();
+        return this.p.harnesses.map((harness) => {
+            const eintrag = zustand.harnessHeime.find((h) => h.harness === harness.name);
+            const primaer = {
+                pfad: this.p.heime.primaer(harness.name),
+                eingestellt: eintrag?.pfad !== undefined && eintrag.pfad.length > 0,
+            };
+            const zusaetzliche = this.p.heime
+                .zusaetzliche(harness.name)
+                .map((h) => ({ adresse: h.adresse, pfad: h.pfad, eingestellt: true }));
+            return {
+                harness: harness.name,
+                heime: [primaer, ...zusaetzliche],
+                kannZusaetzliche: kannZusaetzlicheHeime(harness),
+            };
+        });
+    }
+    /** Der Eintrag dieses Harness im Zustand, notfalls neu angelegt (E78). */
+    static heimEintrag(zustand, harness) {
+        let eintrag = zustand.harnessHeime.find((h) => h.harness === harness);
+        if (eintrag === undefined) {
+            eintrag = { harness, zusaetzliche: [] };
+            zustand.harnessHeime.push(eintrag);
+        }
+        return eintrag;
+    }
+    /** Einträge ohne Inhalt fallen weg, damit die state.json nicht mit leeren Hüllen zuwächst. */
+    static heimeAufraeumen(zustand) {
+        zustand.harnessHeime = zustand.harnessHeime.filter((h) => (h.pfad !== undefined && h.pfad.length > 0) || h.zusaetzliche.length > 0);
+    }
+    /**
+     * Primäres Homedir umstellen (E78, F89): hmgr merkt sich den neuen Pfad und zeigt ab dann ihn.
+     * Was am alten Ort liegt, bleibt unberührt liegen — dasselbe Verhalten wie beim Deaktivieren
+     * (E74). Wer umziehen will, verlinkt am neuen Ort neu; einen Umzugsassistenten gibt es bewusst
+     * nicht. Der Pfad wird nicht geprüft: ein Homedir, das erst noch entsteht, ist ein gültiger Wunsch.
+     */
+    async harnessHeimSetzen(harnessName, pfad) {
+        this.harness(harnessName); // wirft HarnessTypUnbekannt bei unbekanntem Namen
+        const aufgeloest = path.resolve(pfad);
+        const zustand = await this.p.zustand.lesen();
+        Anwendungsfaelle.heimEintrag(zustand, harnessName).pfad = aufgeloest;
+        await this.p.zustand.schreiben(zustand);
+        return aufgeloest;
+    }
+    /** Gegenstück zu `harnessHeimSetzen` (E78, F89): wieder das Home des Nutzers, nichts wird verschoben. */
+    async harnessHeimZuruecksetzen(harnessName) {
+        this.harness(harnessName);
+        const zustand = await this.p.zustand.lesen();
+        const eintrag = zustand.harnessHeime.find((h) => h.harness === harnessName);
+        if (eintrag === undefined || eintrag.pfad === undefined)
+            return;
+        delete eintrag.pfad;
+        Anwendungsfaelle.heimeAufraeumen(zustand);
+        await this.p.zustand.schreiben(zustand);
+    }
+    /**
+     * Zusätzliches Homedir hinzufügen (E78, F87): Adresse `wsl:<distro>`, ohne Benutzer-Option —
+     * wsl.exe startet als Standardbenutzer der Distro, derselbe, der Claude Code dort nutzt. Das Home
+     * wird einmal ermittelt und gespeichert, nicht bei jedem Lauf neu erfragt: sonst hinge jede
+     * Ansicht an einem startenden WSL. Der Aufrufer zeigt den ermittelten Pfad an.
+     */
+    async harnessHeimHinzufuegen(harnessName, adresse) {
+        const harness = this.harness(harnessName);
+        if (!kannZusaetzlicheHeime(harness))
+            throw new HeimFaehigkeitFehlt(harnessName);
+        const zerlegt = heimAdresseZerlegen(adresse);
+        if (zerlegt === undefined)
+            throw new HeimAdresseUngueltig(adresse);
+        const normalisiert = heimAdresseAlsText(zerlegt);
+        // Plattformgrenze (Entscheidung 7): ein WSL-Heim lässt sich nur unter Windows anlegen und
+        // bedienen. Ohne die Prüfung stünde hier ein Eintrag, den derselbe Rechner nie wieder sieht.
+        if (this.p.umgebung.plattform() !== 'win32')
+            throw new HeimNurUnterWindows(normalisiert, this.p.umgebung.plattform());
+        const zustand = await this.p.zustand.lesen();
+        const eintrag = Anwendungsfaelle.heimEintrag(zustand, harnessName);
+        if (eintrag.zusaetzliche.some((h) => h.adresse === normalisiert))
+            throw new HeimBereitsVorhanden(harnessName, normalisiert);
+        const pfad = await this.p.wsl.home(zerlegt.distro);
+        eintrag.zusaetzliche.push({ adresse: normalisiert, pfad });
+        await this.p.zustand.schreiben(zustand);
+        return { adresse: normalisiert, pfad };
+    }
+    /**
+     * Zusätzliches Homedir entfernen (E78): hmgr vergisst es, die Links dort bleiben liegen — wie bei
+     * jedem anderen „nicht mehr gemanagt" (E74, F89). Wer sie los werden will, entfernt sie vorher.
+     */
+    async harnessHeimEntfernen(harnessName, adresse) {
+        this.harness(harnessName);
+        const zerlegt = heimAdresseZerlegen(adresse);
+        const normalisiert = zerlegt === undefined ? adresse : heimAdresseAlsText(zerlegt);
+        const zustand = await this.p.zustand.lesen();
+        const eintrag = zustand.harnessHeime.find((h) => h.harness === harnessName);
+        if (eintrag === undefined || !eintrag.zusaetzliche.some((h) => h.adresse === normalisiert))
+            throw new HeimUnbekannt(harnessName, normalisiert);
+        eintrag.zusaetzliche = eintrag.zusaetzliche.filter((h) => h.adresse !== normalisiert);
+        Anwendungsfaelle.heimeAufraeumen(zustand);
+        await this.p.zustand.schreiben(zustand);
+    }
+    /** Die installierten WSL-Distros, für die Auswahl beim Hinzufügen (E78, F87). */
+    async wslDistros() {
+        if (this.p.umgebung.plattform() !== 'win32')
+            return [];
+        return await this.p.wsl.distros().catch(() => []);
+    }
     /**
      * Harness-Typen, die hmgr verwaltet (E38, GRILL.md Runde 2). Nur für sie richtet hmgr beim
      * Arbeitsverzeichnis-Hinzufügen und beim Abgleich etwas ein. Standard: nur claude-code.
@@ -291,6 +428,8 @@ export class Anwendungsfaelle {
             if (!kannMcp(harness))
                 continue;
             const ebenen = harness.mcp.ebenen();
+            // Nur das primäre Homedir (E78): die claude-CLI dieses Rechners bedient die Konfiguration
+            // einer WSL-Distro nicht, dort gibt es keine MCP-Server zu verwalten.
             if (ebenen.includes('home'))
                 ziele.push({ harness: harness.name, ort: { art: 'home' } });
             if (ebenen.includes('profil') && kannProfile(harness))
@@ -354,9 +493,7 @@ export class Anwendungsfaelle {
     async saeubern(harnessName) {
         const harness = this.harness(harnessName); // wirft HarnessTypUnbekannt bei unbekanntem Namen
         const zustand = await this.p.zustand.lesen();
-        const ziele = [];
-        if (harness.orte().includes('home'))
-            ziele.push({ harness: harness.name, ort: { art: 'home' } });
+        const ziele = [...this.homeZiele(harness)];
         if (harness.orte().includes('profil') && kannProfile(harness))
             for (const name of await harness.profile())
                 ziele.push({ harness: harness.name, ort: { art: 'profil', name } });
@@ -364,6 +501,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 +516,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 +658,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 +705,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 +797,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.harnessAktivGeprueft(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,
@@ -777,7 +1297,7 @@ export class Anwendungsfaelle {
      * hätte sie keinen Platz und der Aufruf schlägt fehl.
      */
     async linkLegen(args) {
-        const harness = await this.harnessGeprueft(args.ziel.harness);
+        const harness = await this.harnessAktivGeprueft(args.ziel.harness);
         if (!harness.orte().includes(args.ziel.ort.art))
             throw new OrtNichtUnterstuetzt(harness.name, args.ziel.ort.art);
         const version = args.version;
@@ -849,28 +1369,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
@@ -1195,9 +1723,15 @@ export class Anwendungsfaelle {
      * Checkouts, deren Quelle der Zustand nicht führt, bleiben ganz außen vor (E54): sie werden weder
      * geholt noch als verwaist zum Löschen angeboten. Eine vergessene Quelle ist vergessen, ihre
      * Checkouts und Links liegen unangetastet, bis die Quelle wieder hinzukommt.
+     *
+     * Schreibt am Ende einen Verlaufseintrag (E80), aber nur, wenn der Lauf mindestens ein Ereignis
+     * ergeben hat: unveränderte oder übersprungene Checkouts und Bundles ohne Änderung erzeugen
+     * nichts, ein leerer Lauf bleibt ganz aus dem Changelog. `ausloeser` steht mit im Eintrag, damit
+     * der Verlauf zeigt, ob ein Fund vom automatischen Lauf, einem Klick oder der CLI kam.
      */
     async aktualisieren(args) {
         const rueckfragen = args?.rueckfragen ?? true;
+        const ausloeser = args?.ausloeser ?? 'cli';
         const bekannt = new Map((await this.p.zustand.lesen()).quellen.map((q) => [quelleSchluessel(q), q]));
         const checkouts = [];
         for (const checkout of await this.p.quellen.checkouts()) {
@@ -1211,7 +1745,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 +1762,126 @@ 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();
+        const aufraeumen = await this.verwaisteAufraeumen(checkouts, rueckfragen);
+        await this.verlaufVermerken(ausloeser, this.aktualisierungsEreignisse(checkouts, bundles, aufraeumen));
+        return { checkouts, pluginHarnesses, bundles, aufraeumen };
+    }
+    /**
+     * Ereignisse eines Aktualisieren-Laufs für den Verlauf (E80): Plugins bleiben draußen, weil sich
+     * eine Änderung dort nicht messen lässt (`claude plugin marketplace update` liefert keine
+     * Auskunft) — die bisherige Zeile „Plugins aktualisiert" war deshalb geschönt.
+     */
+    aktualisierungsEreignisse(checkouts, bundles, aufraeumen) {
+        const ereignisse = [];
+        for (const { checkout, aktualisierung, geaenderteSkills } of checkouts) {
+            if (aktualisierung.ergebnis === 'aktualisiert')
+                ereignisse.push({
+                    art: 'checkout',
+                    quelle: quelleAlsText(checkout.quelle),
+                    ref: checkout.ref,
+                    von: aktualisierung.von,
+                    nach: aktualisierung.nach,
+                    skills: geaenderteSkills,
+                });
+            else if (aktualisierung.ergebnis === 'fehlgeschlagen')
+                ereignisse.push({
+                    art: 'fehler',
+                    betrifft: `${quelleAlsText(checkout.quelle)} @ ${checkout.ref}`,
+                    fehler: aktualisierung.fehler,
+                });
+        }
+        for (const eintrag of bundles) {
+            if (eintrag.ergebnis === 'fehlgeschlagen')
+                ereignisse.push({ art: 'fehler', betrifft: eintrag.bundle, fehler: eintrag.fehler ?? '' });
+            else if (eintrag.gelegt.length > 0 || eintrag.entfernt.length > 0)
+                ereignisse.push({
+                    art: 'bundle',
+                    bundle: eintrag.bundle,
+                    ziel: eintrag.ziel,
+                    gelegt: eintrag.gelegt,
+                    entfernt: eintrag.entfernt,
+                });
+        }
+        for (const verwaist of aufraeumen.verwaiste)
+            if (verwaist.geloescht)
+                ereignisse.push({ art: 'aufgeraeumt', checkout: `${quelleAlsText(verwaist.checkout.quelle)} @ ${verwaist.checkout.ref}` });
+        return ereignisse;
+    }
+    /** Neuen Eintrag vorn anfügen, nur wenn Ereignisse da sind (E80). Kappen übernimmt der Adapter. */
+    async verlaufVermerken(ausloeser, ereignisse) {
+        if (ereignisse.length === 0)
+            return;
+        const daten = await this.p.verlauf.lesen();
+        const eintrag = { zeit: new Date().toISOString(), ausloeser, ereignisse };
+        await this.p.verlauf.schreiben({ gemerkt: daten.gemerkt, eintraege: [eintrag, ...daten.eintraege] });
+    }
+    /** Der Verlauf, neueste zuerst (E80). */
+    async verlauf() {
+        return (await this.p.verlauf.lesen()).eintraege;
+    }
+    /**
+     * Merkt die installierte Version eines hmgr-Pakets (GUI oder CLI) und schreibt bei einem
+     * Versionssprung einen Verlaufseintrag (E80). Der erste Aufruf ohne gemerkte Version merkt nur,
+     * ohne Ereignis — sonst bekäme jede Erstinstallation ein irreführendes „installiert".
+     */
+    async versionsSprungVermerken(paket, version, ausloeser) {
+        const daten = await this.p.verlauf.lesen();
+        const bisher = paket === 'gui' ? daten.gemerkt.gui : daten.gemerkt.cli;
+        if (bisher === version)
+            return;
+        const gemerkt = { ...daten.gemerkt, [paket]: version };
+        if (bisher === undefined) {
+            await this.p.verlauf.schreiben({ gemerkt, eintraege: daten.eintraege });
+            return;
+        }
+        const eintrag = {
+            zeit: new Date().toISOString(),
+            ausloeser,
+            ereignisse: [{ art: 'hmgr-installiert', paket, version }],
+        };
+        await this.p.verlauf.schreiben({ gemerkt, eintraege: [eintrag, ...daten.eintraege] });
+    }
+    /**
+     * Merkt ein hmgr-eigenes Ereignis (GUI-Update geladen oder CLI-Update auf npm verfügbar) einmal
+     * je neuer Version (E80): dieselbe Version taucht nicht in jedem Lauf erneut im Changelog auf.
+     */
+    async hmgrEreignisVermerken(ereignis, ausloeser) {
+        const daten = await this.p.verlauf.lesen();
+        const feld = ereignis.art === 'gui-update-geladen' ? 'guiGeladen' : 'cliVerfuegbar';
+        if (daten.gemerkt[feld] === ereignis.version)
+            return;
+        const gemerkt = { ...daten.gemerkt, [feld]: ereignis.version };
+        const eintrag = { zeit: new Date().toISOString(), ausloeser, ereignisse: [ereignis] };
+        await this.p.verlauf.schreiben({ gemerkt, eintraege: [eintrag, ...daten.eintraege] });
+    }
+    /**
+     * 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
@@ -1573,9 +2233,7 @@ export class Anwendungsfaelle {
         };
         const ergebnis = [];
         for (const harness of await this.vorhandeneHarnesses()) {
-            const ziele = [];
-            if (harness.orte().includes('home'))
-                ziele.push({ harness: harness.name, ort: { art: 'home' } });
+            const ziele = [...this.homeZiele(harness)];
             if (harness.orte().includes('profil') && kannProfile(harness))
                 for (const name of await harness.profile())
                     ziele.push({ harness: harness.name, ort: { art: 'profil', name } });
@@ -1585,7 +2243,9 @@ export class Anwendungsfaelle {
             for (const ziel of ziele) {
                 const verzeichnis = harness.zielVerzeichnis(ziel.ort);
                 const eintraege = await this.p.ziele.eintraege(ziel, verzeichnis).catch(() => []);
-                const plugins = kannPlugins(harness)
+                // Plugins nur am primären Homedir (E78): die claude-CLI dieses Rechners kennt die
+                // Plugin-Konfiguration einer WSL-Distro nicht, ihre user-Liste gehörte zum Windows-Home.
+                const plugins = kannPlugins(harness) && !(ziel.ort.art === 'home' && ziel.ort.heim !== undefined)
                     ? await harness.plugins.installierte(ziel).catch(() => [])
                     : undefined;
                 const zeiger = await this.zeigerFuerZiel(ziel);
@@ -1609,6 +2269,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 +2285,7 @@ export class Anwendungsfaelle {
                     gruende: await this.gruende(harness, ziel, eintraege, zeiger, marktplatzFunde),
                     ignoriert,
                     uebernahme,
+                    bundles,
                     istRegistriert,
                     kannSkillOrdner: skillOrdnerFaehig,
                     ...(plugins === undefined ? {} : { plugins }),