hmgr 0.0.45 → 0.0.47

package/dist/kern/anwendungsfaelle.js

@@ -659,7 +659,7 @@ export class Anwendungsfaelle {
                 await this.p.ziele.linkEntfernen(ziel, verzeichnis, name);
                 entfernteLinks.push(name);
             }
-            if (Anwendungsfaelle.bundlesZerbrechen(nachZustand, ziel, entfernteLinks).length > 0)
+            if (Anwendungsfaelle.bundleVerweiseFallenLassen(nachZustand, ziel))
                 bundlesGeaendert = true;
             const konfigurationZurueckgebaut = kannZurueckbauen(harness) ? await harness.zurueckbauen(ziel.ort) : false;
             zielErgebnisse.push({ ziel, entfernteLinks, konfigurationZurueckgebaut });
@@ -801,12 +801,12 @@ 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.
+        // Wo dabei ein Bundle-Mitglied fiel, gilt es als herausgenommen (E114), wie beim einzelnen
+        // `linkEntfernen`: das Bundle bleibt, der Abgleich legt das Mitglied nicht wieder an.
         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)
+            if (Anwendungsfaelle.bundleMitgliederHerausnehmen(zustand, link.ziel, [link.name]).length > 0)
                 bundlesGeaendert = true;
         if (bundlesGeaendert)
             await this.p.zustand.schreiben(zustand);
@@ -1122,8 +1122,11 @@ export class Anwendungsfaelle {
         }
         return angelegt;
     }
-    /** Die Zugehörigkeit der Links eines Bundles im Ziel merken (E69), einen alten Eintrag ersetzend. */
-    async bundleInstallationMerken(ziel, bundle, skills) {
+    /**
+     * Die Zugehörigkeit der Links eines Bundles im Ziel merken (E69), einen alten Eintrag ersetzend.
+     * `herausgenommen` (E114) wird nur geschrieben, wenn es etwas enthält.
+     */
+    async bundleInstallationMerken(ziel, bundle, skills, herausgenommen = []) {
         const zustand = await this.p.zustand.lesen();
         const schluessel = zielSchluessel(ziel);
         const eigener = bundleSchluessel(bundle);
@@ -1135,27 +1138,43 @@ export class Anwendungsfaelle {
             bundle: bundle.name,
             quelle: bundle.quelle,
             skills,
+            ...(herausgenommen.length === 0 ? {} : { herausgenommen }),
         });
         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.
+     * Herausnehmen (E114 L2, ersetzt das Zerbrechen aus E69): Wird ein einzelner Link entfernt, der
+     * zu einem Bundle gehört, bleibt das Bundle im Ziel und merkt sich das Mitglied als herausgenommen
+     * — auch wenn danach keines mehr verlinkt ist („0 von N", weiter entfernbar). Ändert nur den
+     * übergebenen Zustand, geschrieben wird er vom Aufrufer. Gibt die Namen der betroffenen Bundles
+     * zurück, damit die Oberfläche es sagen kann.
      */
-    static bundlesZerbrechen(zustand, ziel, namen) {
+    static bundleMitgliederHerausnehmen(zustand, ziel, namen) {
         const schluessel = zielSchluessel(ziel);
-        const zerbrochen = [];
-        zustand.bundleInstallationen = zustand.bundleInstallationen.filter((installation) => {
+        const betroffen = [];
+        for (const installation of zustand.bundleInstallationen) {
             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;
+                continue;
+            const raus = installation.skills.filter((name) => namen.includes(name));
+            if (raus.length === 0)
+                continue;
+            installation.skills = installation.skills.filter((name) => !raus.includes(name));
+            installation.herausgenommen = [...(installation.herausgenommen ?? []), ...raus];
+            betroffen.push(installation.bundle);
+        }
+        return betroffen;
+    }
+    /**
+     * Bundle-Verweise eines Ziels fallen lassen, wenn „Säubern" dort alle Links abbaut (E69). Kein
+     * Herausnehmen: Säubern räumt den Harness ab, ein Bundle mit „0 von N" bliebe ein Rest, den der
+     * Nutzer gerade loswerden wollte. Darum fallen alle Verweise des Ziels, auch die von Bundles, von
+     * denen gerade kein Link mehr lag.
+     */
+    static bundleVerweiseFallenLassen(zustand, ziel) {
+        const schluessel = zielSchluessel(ziel);
+        const vorher = zustand.bundleInstallationen.length;
+        zustand.bundleInstallationen = zustand.bundleInstallationen.filter((installation) => zielSchluessel(Anwendungsfaelle.installationZiel(installation)) !== schluessel);
+        return zustand.bundleInstallationen.length !== vorher;
     }
     /**
      * Bundle installieren (E69): das Bundle als Ganzes in ein Ziel. Erst wird alles geprüft — jedes
@@ -1205,9 +1224,11 @@ export class Anwendungsfaelle {
         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.
+     * Bundle entfernen (E69): alle seine noch verlinkten Mitglieder im Ziel und den Bundle-Verweis,
+     * auch nach Teil-Löschung (E114 L2): herausgenommene stehen nicht in `skills` und bleiben
+     * unberührt, ein Link gleichen Namens an ihrer Stelle gehört nicht dem Bundle. Entfernt wird
+     * direkt über den Ziele-Port, nicht über den Anwendungsfall `linkEntfernen` — der macht
+     * Zeiger-Arbeit (E57) und nähme jedes Mitglied einzeln heraus.
      */
     async bundleEntfernen(args) {
         const harness = await this.harnessGeprueft(args.ziel.harness);
@@ -1237,6 +1258,11 @@ export class Anwendungsfaelle {
      * 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).
+     *
+     * Herausgenommene Mitglieder (E114 L5) lässt der Abgleich aus: kein Link, keine Konfliktprüfung
+     * (ein anderer Link gleichen Namens an ihrer Stelle ist dann kein Konflikt). Fällt eines aus der
+     * Definition, fällt es auch aus der Liste. `aufnehmen` holt herausgenommene zurück: 'alle' ist
+     * „Vervollständigen" (L4), eine Namensliste „Wieder verlinken" einzelner Mitglieder (L3).
      */
     async bundleAbgleich(args) {
         const zustand = await this.p.zustand.lesen();
@@ -1256,7 +1282,10 @@ export class Anwendungsfaelle {
                 // 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 { funde: alle, neue } = await this.bundleAufloesen(bundle);
+                const aufnehmen = args?.aufnehmen;
+                const herausgenommen = (installation.herausgenommen ?? []).filter((name) => aufnehmen !== 'alle' && !(aufnehmen ?? []).includes(name) && alle.some((f) => f.skill.name === name));
+                const funde = alle.filter((f) => !herausgenommen.includes(f.skill.name));
                 const verzeichnis = harness.zielVerzeichnis(ziel.ort);
                 const { konflikte } = await this.bundleKonflikte(bundle, ziel, verzeichnis, funde);
                 if (konflikte.length > 0)
@@ -1272,7 +1301,7 @@ export class Anwendungsfaelle {
                     await this.p.ziele.linkEntfernen(ziel, verzeichnis, name);
                     entfernt.push(name);
                 }
-                await this.bundleInstallationMerken(ziel, bundle, namen);
+                await this.bundleInstallationMerken(ziel, bundle, namen, herausgenommen);
                 const gelegt = namen.filter((n) => !installation.skills.includes(n));
                 ergebnis.push({
                     ...kopf,
@@ -1358,19 +1387,101 @@ export class Anwendungsfaelle {
      * dieselbe Weiche wie bei `verwaisteAufraeumen`.
      */
     async doctor(args) {
-        const rueckfragen = args?.rueckfragen ?? true;
+        const ergebnis = await this.doctorPruefen(args?.rueckfragen ?? true);
+        // Nur die SOPS-Befunde kommen in den Verlauf (E115); fehlende Arbeitsverzeichnisse meldet der
+        // alleinstehende doctor wie bisher nur auf der Konsole.
+        await this.sopsVermerken(args?.ausloeser ?? 'cli', ergebnis.sops, true);
+        return ergebnis;
+    }
+    /**
+     * doctor ohne Verlauf, damit der Aktualisieren-Lauf die Befunde in seinen eigenen Eintrag nimmt.
+     * Dazu die SOPS-Prüfung (E115): Checkouts geführter Quellen, deren SOPS-Datei noch verschlüsselt
+     * im Arbeitsbaum liegt, schreibt der Quellen-Port neu, wo die Probe klappt. Sie ist keine
+     * Rückfrage wert: die Datei entspricht dem Commit, nur entschlüsselt.
+     */
+    async doctorPruefen(rueckfragen) {
         const zustand = await this.p.zustand.lesen();
         const fehlend = [];
         for (const pfad of zustand.arbeitsverzeichnisse)
             if (!(await this.p.zeiger.verzeichnisExistiert(pfad)))
                 fehlend.push(pfad);
-        if (fehlend.length === 0 || !rueckfragen)
-            return { fehlendeArbeitsverzeichnisse: fehlend, vergessen: [] };
-        if (!(await this.p.rueckfrage.bestaetigen(doctorFrage(fehlend))))
-            return { fehlendeArbeitsverzeichnisse: fehlend, vergessen: [] };
-        for (const pfad of fehlend)
-            await this.arbeitsverzeichnisVergessen(pfad);
-        return { fehlendeArbeitsverzeichnisse: fehlend, vergessen: [...fehlend] };
+        let vergessen = [];
+        if (fehlend.length > 0 && rueckfragen && (await this.p.rueckfrage.bestaetigen(doctorFrage(fehlend)))) {
+            for (const pfad of fehlend)
+                await this.arbeitsverzeichnisVergessen(pfad);
+            vergessen = [...fehlend];
+        }
+        const sops = [];
+        for (const checkout of await this.gefuehrteCheckouts(zustand.quellen)) {
+            const reparaturen = await this.p.quellen.sopsReparieren(checkout).catch(() => []);
+            for (const reparatur of reparaturen)
+                sops.push({ checkout, ...reparatur });
+        }
+        return { fehlendeArbeitsverzeichnisse: fehlend, vergessen, sops };
+    }
+    /** Checkouts, deren Quelle der Zustand führt (E54), mit dem Anzeigenamen der geführten Quelle. */
+    async gefuehrteCheckouts(quellen) {
+        const bekannt = new Map(quellen.map((q) => [quelleSchluessel(q), q]));
+        const ergebnis = [];
+        for (const checkout of await this.p.quellen.checkouts()) {
+            const gefuehrt = bekannt.get(quelleSchluessel(checkout.quelle));
+            if (gefuehrt !== undefined)
+                ergebnis.push({ ...checkout, quelle: quelleMitNamen(checkout.quelle, gefuehrt.name) });
+        }
+        return ergebnis;
+    }
+    /**
+     * SOPS-Dateien, die im Arbeitsbaum eines Checkouts noch verschlüsselt liegen (E115), für
+     * `hmgr status`. Liest nur, ruft kein sops auf und repariert nichts.
+     */
+    async sopsVerschluesselteDateien() {
+        const ergebnis = [];
+        for (const checkout of await this.gefuehrteCheckouts((await this.p.zustand.lesen()).quellen)) {
+            const dateien = await this.p.quellen.sopsDateien(checkout).catch(() => []);
+            for (const d of dateien)
+                if (d.verschluesselt)
+                    ergebnis.push({ checkout, datei: d.datei });
+        }
+        return ergebnis;
+    }
+    /**
+     * SOPS-Befunde als Verlaufsereignisse (E115). „Verschlüsselt" und ein gescheitertes Neuschreiben
+     * kommen einmal je Datei und Grund (`gemerkt.sops`), „repariert" jedes Mal, wenn es geschieht.
+     * `vollstaendig`: die Befunde decken alle Checkouts ab, dann ersetzen sie die gemerkte Liste;
+     * sonst (ein einzelner Checkout beim Verlinken) kommen sie dazu.
+     */
+    async sopsEreignisse(befunde, vollstaendig) {
+        const bisher = (await this.p.verlauf.lesen()).gemerkt.sops ?? [];
+        const aktuell = [];
+        const ereignisse = [];
+        for (const befund of befunde) {
+            const quelle = quelleAlsText(befund.checkout.quelle);
+            const { ref } = befund.checkout;
+            if (befund.ergebnis === 'repariert') {
+                ereignisse.push({ art: 'sops-repariert', quelle, ref, datei: befund.datei });
+                continue;
+            }
+            const art = befund.ergebnis === 'verschluesselt' ? befund.grund : 'fehlgeschlagen';
+            const schluessel = `${quelle} @ ${ref}: ${befund.datei} | ${art}`;
+            if (aktuell.includes(schluessel))
+                continue;
+            aktuell.push(schluessel);
+            if (bisher.includes(schluessel))
+                continue;
+            if (befund.ergebnis === 'verschluesselt')
+                ereignisse.push({ art: 'sops-verschluesselt', quelle, ref, datei: befund.datei, grund: befund.grund });
+            else
+                ereignisse.push({
+                    art: 'fehler',
+                    betrifft: `${quelle} @ ${ref}: ${befund.datei}`,
+                    fehler: `verschlüsselte Datei nicht neu geschrieben: ${befund.fehler}`,
+                });
+        }
+        return { ereignisse, gemerkt: vollstaendig ? aktuell : [...new Set([...bisher, ...aktuell])] };
+    }
+    async sopsVermerken(ausloeser, befunde, vollstaendig) {
+        const { ereignisse, gemerkt } = await this.sopsEreignisse(befunde, vollstaendig);
+        await this.verlaufVermerken(ausloeser, ereignisse, gemerkt);
     }
     /**
      * Mehrere composer.json unter einem Verzeichnis (E26): hmgr rät nicht, es fragt. Bleibt die Frage
@@ -1451,7 +1562,11 @@ export class Anwendungsfaelle {
             throw new OrtNichtUnterstuetzt(harness.name, ziel.ort.art);
         const verzeichnis = harness.zielVerzeichnis(ziel.ort);
         // Die Prüfung auf einen fremden Eintrag macht der Ziele-Port unmittelbar vor dem Anlegen (E12).
-        const checkout = await this.p.quellen.checkout(fund.quelle, fund.ref, [fund.skill]);
+        // Nur Quelle, Ref und Pfad gehen in den Link, die SOPS-Befunde nicht.
+        const { sopsVerschluesselt, ...checkout } = await this.p.quellen.checkout(fund.quelle, fund.ref, [fund.skill]);
+        // Verschlüsselt angekommene SOPS-Dateien (E115) gleich melden, nicht erst beim nächsten Lauf.
+        if (sopsVerschluesselt.length > 0)
+            await this.sopsVermerken('aktion', sopsVerschluesselt.map((v) => ({ checkout, datei: v.datei, ergebnis: 'verschluesselt', grund: v.grund })), false);
         await harness.vorbereiten(ziel.ort);
         await this.p.ziele.linkLegen(ziel, verzeichnis, fund.skill.name, checkout, fund.skill, ersetzen);
         return { ziel, name: fund.skill.name, checkout, skill: fund.skill };
@@ -1486,7 +1601,8 @@ export class Anwendungsfaelle {
         const version = args.version;
         if (version === undefined) {
             const fund = await this.skillFinden(args.skill, args.quelle);
-            return await this.linkAusFund(harness, args.ziel, fund, args.ersetzen, args.lokal);
+            const ergebnis = await this.linkAusFund(harness, args.ziel, fund, args.ersetzen, args.lokal);
+            return Anwendungsfaelle.hinweisAnhaengen(ergebnis, await this.bundleMitgliedZurueckholen(args.ziel, fund));
         }
         if (args.lokal === true || args.ziel.ort.art !== 'arbeitsverzeichnis')
             throw new EinschraenkungOhneZeiger(args.ziel, version);
@@ -1500,7 +1616,57 @@ export class Anwendungsfaelle {
         const link = await this.linkAnlegen(harness, args.ziel, fund, args.ersetzen);
         await this.zeigerErgaenzen(zeigerPfad, fund, version);
         const hinweis = await this.harnessHinweis(harness, args.ziel.ort);
-        return hinweis === undefined ? link : { ...link, hinweis };
+        return Anwendungsfaelle.hinweisAnhaengen(hinweis === undefined ? link : { ...link, hinweis }, await this.bundleMitgliedZurueckholen(args.ziel, fund));
+    }
+    /** Weitere Hinweiszeilen an ein Link-Ergebnis hängen, ohne einen vorhandenen Hinweis zu verdrängen. */
+    static hinweisAnhaengen(ergebnis, zeilen) {
+        if (zeilen.length === 0)
+            return ergebnis;
+        const alle = ergebnis.hinweis === undefined ? zeilen : [ergebnis.hinweis, ...zeilen];
+        return { ...ergebnis, hinweis: alle.join('\n') };
+    }
+    /**
+     * `link` eines herausgenommenen Bundle-Mitglieds (E114 L6): Ist es derselbe Skill aus derselben
+     * Quelle, wie ihn die Definition nennt (Quelle und Pfad, dieselbe Probe wie die Übernahme in
+     * F67), gehört er wieder zum Bundle. Die Definition wird nur gelesen, wenn der Name in diesem
+     * Ziel herausgenommen ist; lässt sie sich nicht lesen, bleibt es beim Einzel-Link. Gibt je
+     * zurückgeholtem Bundle eine Hinweiszeile zurück.
+     */
+    async bundleMitgliedZurueckholen(ziel, fund) {
+        const name = fund.skill.name;
+        const kandidaten = Anwendungsfaelle.installationenAn(await this.p.zustand.lesen(), ziel).filter((i) => (i.herausgenommen ?? []).includes(name));
+        if (kandidaten.length === 0)
+            return [];
+        const passend = [];
+        for (const installation of kandidaten) {
+            try {
+                const bundle = await this.bundleAusQuelle(installation.bundle, installation.quelle);
+                const gleich = bundle.mitglieder.some((m) => quelleSchluessel(m.quelle) === quelleSchluessel(fund.quelle) && m.pfad === fund.skill.pfad);
+                if (gleich)
+                    passend.push(bundleSchluessel(bundle));
+            }
+            catch {
+                // Definition nicht lesbar: der Link bleibt ein Einzel-Link, das Mitglied herausgenommen.
+            }
+        }
+        if (passend.length === 0)
+            return [];
+        const zustand = await this.p.zustand.lesen();
+        const zeilen = [];
+        for (const installation of Anwendungsfaelle.installationenAn(zustand, ziel)) {
+            if (!passend.includes(bundleSchluessel({ name: installation.bundle, quelle: installation.quelle })))
+                continue;
+            const rest = (installation.herausgenommen ?? []).filter((n) => n !== name);
+            if (rest.length === 0)
+                delete installation.herausgenommen;
+            else
+                installation.herausgenommen = rest;
+            if (!installation.skills.includes(name))
+                installation.skills.push(name);
+            zeilen.push(`„${name}" gehört wieder zum Bundle „${installation.bundle}".`);
+        }
+        await this.p.zustand.schreiben(zustand);
+        return zeilen;
     }
     /** Link legen, wenn Quelle, Ref und Skill schon feststehen. Die Zeiger-Arbeit ist dieselbe. */
     async linkAusFund(harness, ziel, fund, ersetzen, lokal) {
@@ -1553,9 +1719,9 @@ 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.
+     * Gehörte der Link zu einem Bundle, bleibt das Bundle im Ziel und merkt sich den Skill als
+     * herausgenommen (E114 L2). `herausgenommenAus` nennt die Bundles, damit die Oberfläche es sagen
+     * kann.
      */
     async linkEntfernen(args) {
         const harness = await this.harnessGeprueft(args.ziel.harness);
@@ -1563,25 +1729,25 @@ export class Anwendungsfaelle {
         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)
+        const herausgenommenAus = Anwendungsfaelle.bundleMitgliederHerausnehmen(zustand, args.ziel, [args.skill]);
+        if (herausgenommenAus.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).', zerbrochen };
-            return { zerbrochen };
+                return { hinweis: 'Der Link ist nur lokal entfernt, der Zeiger bleibt unangetastet (F32).', herausgenommenAus };
+            return { herausgenommenAus };
         }
         if (args.lokal === true || args.ziel.ort.art !== 'arbeitsverzeichnis')
-            return { zerbrochen };
+            return { herausgenommenAus };
         const zeigerPfad = await this.bindungFinden(args.ziel);
         if (zeigerPfad === undefined)
-            return { zerbrochen };
+            return { herausgenommenAus };
         const zeiger = await this.p.zeiger.lesen(zeigerPfad);
         if (!zeiger.skills.delete(args.skill))
-            return { zerbrochen };
+            return { herausgenommenAus };
         await this.p.zeiger.schreiben(zeigerPfad, zeiger);
-        return { zerbrochen };
+        return { herausgenommenAus };
     }
     /**
      * Ignoriert einen fremden Eintrag (E43): idempotent, kein Duplikat. Gleichheit über harness, Ort
@@ -1996,9 +2162,15 @@ export class Anwendungsfaelle {
             ? { verwaiste: [], gefragt: false }
             : await this.verwaisteAufraeumen(checkouts, rueckfragen);
         const doctorErgebnis = nurSchluessel !== undefined
-            ? { fehlendeArbeitsverzeichnisse: [], vergessen: [] }
-            : await this.doctor({ rueckfragen });
-        await this.verlaufVermerken(ausloeser, this.aktualisierungsEreignisse(checkouts, pluginFehler, bundles, aufraeumen, doctorErgebnis));
+            ? { fehlendeArbeitsverzeichnisse: [], vergessen: [], sops: [] }
+            : await this.doctorPruefen(rueckfragen);
+        // Die SOPS-Befunde (E115) kommen in denselben Eintrag; ein eingeschränkter Lauf prüft sie nicht
+        // und lässt die gemerkte Liste stehen.
+        const sops = nurSchluessel !== undefined ? undefined : await this.sopsEreignisse(doctorErgebnis.sops, true);
+        await this.verlaufVermerken(ausloeser, [
+            ...this.aktualisierungsEreignisse(checkouts, pluginFehler, bundles, aufraeumen, doctorErgebnis),
+            ...(sops?.ereignisse ?? []),
+        ], sops?.gemerkt);
         return { checkouts, pluginHarnesses, pluginFehler, bundles, aufraeumen, doctor: doctorErgebnis };
     }
     /**
@@ -2049,13 +2221,23 @@ export class Anwendungsfaelle {
             ereignisse.push({ art: 'arbeitsverzeichnis-vergessen', pfad });
         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;
+    /**
+     * Neuen Eintrag vorn anfügen, nur wenn Ereignisse da sind (E80). Kappen übernimmt der Adapter.
+     * `sopsGemerkt` (E115) ersetzt die gemerkten SOPS-Meldungen; hat sich nur diese Liste geändert,
+     * wird sie ohne neuen Eintrag geschrieben.
+     */
+    async verlaufVermerken(ausloeser, ereignisse, sopsGemerkt) {
         const daten = await this.p.verlauf.lesen();
+        const sopsGeaendert = sopsGemerkt !== undefined && JSON.stringify(sopsGemerkt) !== JSON.stringify(daten.gemerkt.sops ?? []);
+        if (ereignisse.length === 0 && !sopsGeaendert)
+            return;
+        const gemerkt = sopsGeaendert ? { ...daten.gemerkt, sops: sopsGemerkt } : daten.gemerkt;
+        if (ereignisse.length === 0) {
+            await this.p.verlauf.schreiben({ gemerkt, eintraege: daten.eintraege });
+            return;
+        }
         const eintrag = { zeit: new Date().toISOString(), ausloeser, ereignisse };
-        await this.p.verlauf.schreiben({ gemerkt: daten.gemerkt, eintraege: [eintrag, ...daten.eintraege] });
+        await this.p.verlauf.schreiben({ gemerkt, eintraege: [eintrag, ...daten.eintraege] });
     }
     /** Der Verlauf, neueste zuerst (E80). */
     async verlauf() {
@@ -2580,14 +2762,20 @@ 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.
+                // Bundles dieses Ziels (E69), rein aus dem Zustand: verlinkt sind die Mitglieder, die dort
+                // auch wirklich noch liegen; herausgenommene und von Hand gelöschte stehen als nicht
+                // verlinkt daneben (E114 L3), die Gruppe zeigt alle.
                 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)),
-                }));
+                const bundles = Anwendungsfaelle.installationenAn(zustand, ziel).map((i) => {
+                    const herausgenommen = i.herausgenommen ?? [];
+                    return {
+                        name: i.bundle,
+                        quelle: i.quelle,
+                        skills: i.skills.filter((name) => eigeneNamen.has(name)),
+                        nichtVerlinkt: [...i.skills.filter((name) => !eigeneNamen.has(name)), ...herausgenommen],
+                        herausgenommen,
+                    };
+                });
                 ergebnis.push({
                     ziel,
                     verzeichnis,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hmgr",
-  "version": "0.0.45",
+  "version": "0.0.47",
   "description": "Harness Manager: Skills und Plugins für AI-Harnesses verwalten",
   "license": "MIT",
   "author": "Tim Kaufmann",