hmgr 0.0.44 → 0.0.46

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,
@@ -1486,7 +1515,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 +1530,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 +1633,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 +1643,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
@@ -2580,14 +2660,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.44",
+  "version": "0.0.46",
   "description": "Harness Manager: Skills und Plugins für AI-Harnesses verwalten",
   "license": "MIT",
   "author": "Tim Kaufmann",