hmgr 0.0.5 → 0.0.7

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, 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, kannPlugins, kannProfile, kannSkillOrdner, kannZurueckbauen, } from "../ports/harness.js";
+import { kannIstRegistriert, kannMcp, kannPlugins, kannProfile, kannSkillOrdner, kannZurueckbauen, } 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.
@@ -24,6 +24,22 @@ function ignorierterEintragGleich(i, args) {
 function fehlertext(fehler) {
     return fehler instanceof Error ? fehler.message : String(fehler);
 }
+/**
+ * `${VAR}`- und `${env:VAR}`-Verweise in einem MCP-Konfigblock, ohne Dubletten (E61, F39).
+ * Exportiert, damit die GUI dieselbe Prüfung für den Warn-Vermerk an der Katalog-Karte
+ * wiederverwenden kann (E61-Folgerunde), statt sie nachzubauen.
+ */
+export function variablenVerweise(konfig) {
+    const texte = 'command' in konfig
+        ? [konfig.command, ...(konfig.args ?? []), ...Object.values(konfig.env ?? {})]
+        : [konfig.url, ...Object.values(konfig.headers ?? {})];
+    const namen = new Set();
+    const muster = /\$\{(?:env:)?([A-Za-z_][A-Za-z0-9_]*)\}/g;
+    for (const text of texte)
+        for (const treffer of text.matchAll(muster))
+            namen.add(treffer[1]);
+    return [...namen];
+}
 /**
  * Quellenhinweis bei Mehrdeutigkeit (E12): Teilstring des Schlüssels oder der Schreibweise. Beides
  * zählt, damit `host/besitzer/repo` genauso greift wie ein Stück der URL, unter der die Quelle
@@ -174,6 +190,160 @@ export class Anwendungsfaelle {
         const harness = await this.harnessGeprueft(ziel.harness);
         await this.harnessMitSkillOrdner(harness.name).skillOrdnerLoeschen(ziel.ort, pfad);
     }
+    /** Ein Harness mit der Fähigkeit MCP-Server (E61), sonst `McpFaehigkeitFehlt`. */
+    harnessMitMcp(name) {
+        const harness = this.harness(name);
+        if (!kannMcp(harness))
+            throw new McpFaehigkeitFehlt(name);
+        return harness;
+    }
+    /** MCP-Katalog, unverändert wie in ~/.hmgr/mcp.yaml gepflegt (E61). hmgr schreibt ihn nie. */
+    async mcpKatalog() {
+        return await this.p.mcpKatalog.lesen();
+    }
+    async mcpEintragFinden(mcpName) {
+        const eintrag = (await this.p.mcpKatalog.lesen()).find((e) => e.name === mcpName);
+        if (eintrag === undefined)
+            throw new McpUnbekannt(mcpName);
+        return eintrag;
+    }
+    /**
+     * F39: fehlende `${VAR}`-Verweise als Warnung, nie als Abbruch. Geprüft wird gegen die eigene
+     * Prozess-Umgebung und, wenn die Fähigkeit eine `.env`-Datei nennt (Hermes), zusätzlich gegen sie.
+     */
+    async mcpVariablenWarnung(faehig, eintrag, ort) {
+        const verweise = variablenVerweise(eintrag.konfig);
+        if (verweise.length === 0)
+            return undefined;
+        const prozessEnv = this.p.umgebung.variablen();
+        const envPfad = faehig.mcp.envDatei?.(ort);
+        const zusatzEnv = envPfad === undefined ? {} : await this.p.umgebung.envDatei(envPfad);
+        const fehlend = verweise.filter((v) => !(v in prozessEnv) && !(v in zusatzEnv));
+        if (fehlend.length === 0)
+            return undefined;
+        const mehrzahl = fehlend.length > 1;
+        return (`hmgr kann nicht wissen, was die Shell beim Start des Harness setzt: ` +
+            `${mehrzahl ? 'Variablen' : 'Variable'} ${fehlend.join(', ')} ${mehrzahl ? 'sind' : 'ist'} weder in der ` +
+            'aktuellen Umgebung noch in einer bekannten .env-Datei zu finden.');
+    }
+    /**
+     * MCP einhängen (E61): Katalog-Eintrag an ein Ziel legen, Projekt oder global. Die Fähigkeit hängt
+     * am Adapter (E16): ein Harness ohne MCP-Fähigkeit oder ohne diese Ebene ist ein Fehler. Ein
+     * fehlender `${VAR}`-Verweis bricht nicht ab, sondern kommt als Warnung zurück (F39).
+     */
+    async mcpEinhaengen(args) {
+        const eintrag = await this.mcpEintragFinden(args.name);
+        const harness = await this.harnessGeprueft(args.ziel.harness);
+        const faehig = this.harnessMitMcp(harness.name);
+        if (!faehig.mcp.ebenen().includes(args.ziel.ort.art))
+            throw new McpEbeneNichtUnterstuetzt(harness.name, args.ziel.ort.art);
+        await faehig.mcp.einhaengen(eintrag.name, eintrag.konfig, args.ziel.ort);
+        const warnung = await this.mcpVariablenWarnung(faehig, eintrag, args.ziel.ort);
+        const hinweis = faehig.mcp.hinweisNachAenderung?.();
+        return {
+            eintrag,
+            ziel: args.ziel,
+            ...(hinweis === undefined ? {} : { hinweis }),
+            ...(warnung === undefined ? {} : { warnung }),
+        };
+    }
+    /** MCP aushängen (E61): Gegenstück zu `mcpEinhaengen`, ohne F39-Prüfung. */
+    async mcpAushaengen(args) {
+        const eintrag = await this.mcpEintragFinden(args.name);
+        const harness = await this.harnessGeprueft(args.ziel.harness);
+        const faehig = this.harnessMitMcp(harness.name);
+        if (!faehig.mcp.ebenen().includes(args.ziel.ort.art))
+            throw new McpEbeneNichtUnterstuetzt(harness.name, args.ziel.ort.art);
+        await faehig.mcp.aushaengen(eintrag.name, args.ziel.ort);
+        const hinweis = faehig.mcp.hinweisNachAenderung?.();
+        return { eintrag, ziel: args.ziel, ...(hinweis === undefined ? {} : { hinweis }) };
+    }
+    /**
+     * MCP übernehmen (E64, F48=O2): einen Eintrag aus der geteilten Konfigurationsdatei eines Ortes
+     * (bei Claude Code die `.mcp.json` der Projektwurzel) in den privaten Bereich desselben Ortes
+     * holen — eintragen und aus der geteilten Datei entfernen. Der Konfigblock kommt 1:1 aus der
+     * Datei, nicht aus dem Katalog: es gibt Einträge, die der Katalog nicht kennt, und beide Sorten
+     * müssen gehen. Die Fähigkeit hängt am Adapter (E16), nicht am Namen: fehlt sie, kennt dieser
+     * Harness-Typ keine geteilte Datei.
+     */
+    async mcpUebernehmen(args) {
+        const harness = await this.harnessGeprueft(args.ziel.harness);
+        const faehig = this.harnessMitMcp(harness.name);
+        const uebernehmen = faehig.mcp.geteiltenUebernehmen;
+        if (uebernehmen === undefined)
+            throw new McpUebernahmeNichtMoeglich(args.ziel);
+        const { datei } = await uebernehmen.call(faehig.mcp, args.name, args.ziel.ort);
+        const hinweis = faehig.mcp.hinweisNachAenderung?.();
+        return { name: args.name, ziel: args.ziel, datei, ...(hinweis === undefined ? {} : { hinweis }) };
+    }
+    /**
+     * Alle Orte, an denen MCP-Server grundsätzlich hängen können (E61): je Harness mit der Fähigkeit
+     * (E16, am Adapter abgefragt, nie am Namen) seine Ebenen aufgelöst zu tatsächlichen Zielen — Home,
+     * jedes bekannte Profil, jedes bekannte Arbeitsverzeichnis. Unabhängig davon, ob dort schon etwas
+     * hängt oder der Harness gerade aktiv ist (E38): das entscheidet der Aufrufer. Geteilt zwischen
+     * `mcpUebersicht` (dort mit `eingehaengte` abgeglichen) und `mcpPlaetze` (roh für den
+     * Einhängen-Dialog der GUI).
+     */
+    async mcpZiele() {
+        const ziele = [];
+        const zustand = await this.p.zustand.lesen();
+        for (const harness of await this.vorhandeneHarnesses()) {
+            if (!kannMcp(harness))
+                continue;
+            const ebenen = harness.mcp.ebenen();
+            if (ebenen.includes('home'))
+                ziele.push({ harness: harness.name, ort: { art: 'home' } });
+            if (ebenen.includes('profil') && kannProfile(harness))
+                for (const name of await harness.profile())
+                    ziele.push({ harness: harness.name, ort: { art: 'profil', name } });
+            if (ebenen.includes('arbeitsverzeichnis'))
+                for (const pfad of zustand.arbeitsverzeichnisse)
+                    ziele.push(arbeitsverzeichnisZiel(harness.name, pfad));
+        }
+        return ziele;
+    }
+    /**
+     * Die Plätze für den Einhängen-Dialog der GUI (E61-Folgerunde, F42): dieselbe Liste wie in
+     * `mcpUebersicht`, aber roh, ohne den Abgleich mit Katalog-Einträgen. Die Fähigkeit hängt am
+     * Adapter, nicht am Harness-Namen (E16): agents kommt nie vor, weil es `mcp` nicht implementiert.
+     */
+    async mcpPlaetze() {
+        return this.mcpZiele();
+    }
+    /**
+     * Übersicht für `hmgr mcp list` (E61): je Katalog-Eintrag, wo er eingehängt ist, dazu Einträge in
+     * Harness-Konfigurationen, die nicht im Katalog stehen (nur genannt, nicht angefasst).
+     */
+    async mcpUebersicht() {
+        const katalog = (await this.p.mcpKatalog.lesen()).map((eintrag) => ({
+            eintrag,
+            eingehaengt: [],
+            geteilteFundorte: [],
+        }));
+        const nachName = new Map(katalog.map((k) => [k.eintrag.name, k]));
+        const unbekannt = [];
+        const unbekannteGeteilteFundorte = [];
+        for (const ziel of await this.mcpZiele()) {
+            const faehig = this.harnessMitMcp(ziel.harness);
+            const namen = await faehig.mcp.eingehaengte(ziel.ort).catch(() => []);
+            for (const mcpName of namen) {
+                const eintrag = nachName.get(mcpName);
+                if (eintrag !== undefined)
+                    eintrag.eingehaengt.push(ziel);
+                else
+                    unbekannt.push({ ziel, name: mcpName });
+            }
+            const geteilt = (await faehig.mcp.geteilteFundorte?.(ziel.ort).catch(() => [])) ?? [];
+            for (const fundort of geteilt) {
+                const eintrag = nachName.get(fundort.name);
+                if (eintrag !== undefined)
+                    eintrag.geteilteFundorte.push({ ziel, datei: fundort.datei, scope: fundort.scope });
+                else
+                    unbekannteGeteilteFundorte.push({ ziel, name: fundort.name, datei: fundort.datei, scope: fundort.scope });
+            }
+        }
+        return { katalog, unbekannt, unbekannteGeteilteFundorte };
+    }
     /**
      * Säubern (E38): entfernt in allen Zielen dieses Harness-Typs (Home, Profile, bekannte
      * Arbeitsverzeichnisse) die von hmgr angelegten Links und baut harness-eigene Einträge zurück, die
@@ -194,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(() => []);
@@ -205,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 };
     }
     /**
@@ -343,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 };
@@ -381,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) });
@@ -460,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,
@@ -679,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
@@ -1041,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 = [];
@@ -1051,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
@@ -1171,8 +1773,9 @@ export class Anwendungsfaelle {
             if (!enthalten)
                 return unbekannt('lokale-aenderungen');
             const quelle = normalisiert(quelleRoh);
-            // Der übliche Katalog (skills()) kennt nur Skills unter einem Unterverzeichnis (E11), ein
-            // Wurzel-Skill der ganzen Arbeitskopie kommt darin nicht vor. Er wird direkt gelesen (E48 a).
+            // Der Katalog (skills()) kennt einen Wurzel-Skill zwar seit dem E11-Nachtrag, aber er gilt
+            // für die geführte Quelle am gefragten Ref. Hier liegt eine fremde Arbeitskopie an Ort und
+            // Stelle: ihr Wurzel-Skill wird direkt von der Platte gelesen, ohne Clone (E48 a).
             const skill = await this.p.quellen.wurzelSkill(entryPfad).catch(() => null);
             if (skill === null)
                 return unbekannt('skill-unbekannt');
@@ -1438,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,
@@ -1446,6 +2057,7 @@ export class Anwendungsfaelle {
                     gruende: await this.gruende(harness, ziel, eintraege, zeiger, marktplatzFunde),
                     ignoriert,
                     uebernahme,
+                    bundles,
                     istRegistriert,
                     kannSkillOrdner: skillOrdnerFaehig,
                     ...(plugins === undefined ? {} : { plugins }),