hmgr 0.0.45 → 0.0.46

package/dist/adapter/zustand-json.js

@@ -18,7 +18,8 @@ function deuten(roh) {
         aktiveHarnesses: (daten.aktiveHarnesses ?? ['claude-code']),
         // Fehlt das Feld (state.json vor E43), gilt: nichts ignoriert.
         ignorierteEintraege: (daten.ignorierteEintraege ?? []),
-        // Fehlt das Feld (state.json vor E69), gilt: kein Bundle installiert.
+        // Fehlt das Feld (state.json vor E69), gilt: kein Bundle installiert. Ein Eintrag ohne
+        // `herausgenommen` (vor E114) hat keine herausgenommenen Mitglieder, das Feld bleibt dann weg.
         bundleInstallationen: (daten.bundleInstallationen ?? []),
         // Fehlt das Feld (state.json vor E78), gilt: jeder Harness hat nur sein Standard-Homedir.
         harnessHeime: (daten.harnessHeime ?? []),

package/dist/aenderungen.json

@@ -1,6 +1,9 @@
 {
   "fassung": 1,
   "versionen": {
+    "0.0.46": [
+      "Bundles lassen sich aufklappen und zeigen ihre Skills mit Beschreibung, auch schon im Dialog „Skills hinzufügen“. Entfernst du einen einzelnen Skill, bleibt das Bundle bestehen und zeigt, was fehlt; mit „Vervollständigen“ oder „Wieder verlinken“ holst du Skills zurück, und „Entfernen“ am Bundle räumt den Rest weg."
+    ],
     "0.0.45": [
       "MCP-Server und die Listen in den Einstellungen (Harnesses, zusätzliche Homedirs) erscheinen jetzt alphabetisch sortiert, ebenso in hmgr mcp list."
     ],

package/dist/cli/hilfe.js

@@ -315,9 +315,13 @@ Liegt am Ziel schon derselbe Skill aus derselben Quelle als hmgr-Link, wird er a
 übernommen: aus Bestand wird ein Bundle, ohne erst Links von Hand zu entfernen. Alles andere unter
 demselben Namen ist ein Konflikt und wird genannt.
 
-hmgr unlink <skill> auf ein einzelnes Mitglied zerbricht das Bundle in diesem Ziel: die übrigen
-Links bleiben als einzelne Links liegen, der Bundle-Verweis fällt weg. Das ist kein Fehler, hmgr
-sagt es nur.
+hmgr unlink <skill> auf ein einzelnes Mitglied nimmt es aus dem Bundle heraus: nur dieser Link
+verschwindet, das Bundle bleibt im Ziel und merkt sich den Skill als herausgenommen. sync und
+update legen ihn nicht wieder an, neue Mitglieder der Definition ergänzen sie weiter. Zurück kommt
+er mit hmgr link <skill> desselben Skills aus derselben Quelle oder mit bundle sync --complete, das
+alle fehlenden Mitglieder verlinkt. remove nimmt die noch verlinkten Mitglieder weg, auch wenn
+schon welche herausgenommen sind. hmgr status und bundle list zeigen die Lage je Ziel, etwa
+„4/5 … fehlt: x".
 
 Den Abgleich macht schon hmgr update für alle installierten Bundles mit, es ist derselbe Vorgang
 und dieselbe Ausgabe (E69): eine geänderte Definition kommt also mit dem gewöhnlichen
@@ -335,11 +339,14 @@ Schalter (add, remove und sync):
                       kennt nur hermes, wsl:<distro> nur claude-code unter Windows (E78)
   --composer <pfad>   composer.json des Arbeitsverzeichnisses, wenn mehrere in Frage kommen
   --quelle <teil>     nur bei add: Quelle eingrenzen, wenn den Namen mehrere Quellen führen
+  --complete          nur bei sync: auch herausgenommene Mitglieder verlinken (Vervollständigen),
+                      die Liste der herausgenommenen ist danach leer. Auch --vervollstaendigen
 
 Beispiele:
   hmgr bundle list
   hmgr bundle add wordpress --ort dir:.
   hmgr bundle sync
+  hmgr bundle sync wordpress --ort dir:. --complete
   hmgr bundle remove wordpress --ort dir:.
 
 Häufige Fälle:

package/dist/cli/main.js

@@ -125,7 +125,7 @@ const SCHALTER = {
     unlink: { werte: ['harness', 'ort', 'composer'], flaggen: ['local', 'lokal'] },
     adopt: { werte: ['harness', 'ort', 'composer'], flaggen: ['local', 'lokal', 'probelauf'] },
     plugin: { werte: ['harness', 'ort', 'composer', 'quelle'], flaggen: ['local', 'lokal'] },
-    bundle: { werte: ['harness', 'ort', 'composer', 'quelle'], flaggen: [] },
+    bundle: { werte: ['harness', 'ort', 'composer', 'quelle'], flaggen: ['complete', 'vervollstaendigen'] },
     mcp: { werte: ['harness', 'ort'], flaggen: [] },
     sync: { werte: [], flaggen: [] },
     update: { werte: ['quelle'], flaggen: [] },
@@ -160,7 +160,8 @@ const UNTERKOMMANDOS = {
         add: { woerter: 2, schalter: ['harness', 'ort', 'composer', 'quelle'] },
         remove: { woerter: 2, schalter: ['harness', 'ort', 'composer'] },
         // sync nimmt einen Bundle-Namen, aber keinen zwingend: ohne Namen gilt der ganze Bestand.
-        sync: { woerter: 2, schalter: ['harness', 'ort', 'composer'] },
+        // --complete/--vervollstaendigen holt herausgenommene Mitglieder zurück (E114 L4).
+        sync: { woerter: 2, schalter: ['harness', 'ort', 'composer', 'complete', 'vervollstaendigen'] },
         list: { woerter: 1, schalter: [] },
     },
     mcp: {
@@ -491,9 +492,10 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
         if (kommando === 'unlink') {
             const ergebnis = await anwendungsfaelle.linkEntfernen({ skill, ziel, lokal });
             console.log(`Link ${skill} entfernt.`);
-            // Zerbrochen (E69): die übrigen Links des Bundles bleiben als Einzel-Installationen liegen.
-            for (const bundle of ergebnis.zerbrochen)
-                console.log(`Bundle „${bundle}" ist damit zerbrochen, seine übrigen Links bleiben als einzelne Links liegen.`);
+            // Herausgenommen (E114 L2): das Bundle bleibt, der Abgleich legt den Skill nicht wieder an.
+            for (const bundle of ergebnis.herausgenommenAus)
+                console.log(`„${skill}" ist aus dem Bundle „${bundle}" herausgenommen, das Bundle bleibt. ` +
+                    `Zurück mit hmgr link ${skill} oder hmgr bundle sync ${bundle} --complete.`);
             if (ergebnis.hinweis !== undefined)
                 console.log(ergebnis.hinweis);
             return 0;
@@ -612,10 +614,15 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
     if (kommando === 'bundle') {
         const schalter = schalterLesen(argv.slice(1), 'bundle');
         unterkommandoPruefen('bundle', schalter);
-        const { rest, werte } = schalter;
+        const { rest, werte, flaggen } = schalter;
         const unterkommando = rest[0];
         if (unterkommando === 'list') {
             const katalog = await anwendungsfaelle.bundleKatalog();
+            // Je Bundle die Ziele, in denen es liegt, mit seiner Lage (E114 L6). Nur nötig, wenn
+            // überhaupt ein Bundle installiert ist; der Ist-Zustand kostet sonst einen Scan aller Ziele.
+            const installiert = (await ports.zustand.lesen()).bundleInstallationen.length > 0
+                ? (await anwendungsfaelle.istZustand({ plugins: false })).flatMap((z) => z.bundles.map((b) => ({ ziel: z.ziel, bundle: b })))
+                : [];
             const leer = katalog.every((k) => k.bundles.length === 0 && k.kaputte.length === 0 && k.fehler === undefined);
             if (leer)
                 console.log('Keine Quelle mit Bundles. hmgr help bundle zeigt das Format von bundles/<name>.yaml.');
@@ -631,6 +638,9 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
                     console.log(`  ${bundle.name}  ${kappen(bundle.beschreibung)}`);
                     for (const mitglied of bundle.mitglieder)
                         console.log(`    ${mitglied.pfad}  aus ${quelleAlsText(mitglied.quelle)}`);
+                    for (const { ziel, bundle: lage } of installiert)
+                        if (lage.name === bundle.name && quelleSchluessel(lage.quelle) === quelleSchluessel(bundle.quelle))
+                            console.log(`    installiert  ${ziel.harness} ${beschreibeOrt(ziel.ort)}  ${bundleLage(lage)}`);
                 }
                 // Eine kaputte Definition verdeckt die übrigen nicht, sie wird eigens genannt (E69).
                 for (const kaputt of eintrag.kaputte)
@@ -683,9 +693,11 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
         }
         // sync: ohne Ziel-Schalter der ganze Bestand, mit --ort/--harness nur dieses Ziel.
         const nurZiel = werte.has('harness') || werte.has('ort');
+        const vervollstaendigen = flaggen.has('complete') || flaggen.has('vervollstaendigen');
         const eintraege = await anwendungsfaelle.bundleAbgleich({
             ...(name === undefined ? {} : { bundle: name }),
             ...(nurZiel ? { ziel } : {}),
+            ...(vervollstaendigen ? { aufnehmen: 'alle' } : {}),
         });
         if (eintraege.length === 0)
             console.log('Kein Bundle installiert, nichts abzugleichen.');
@@ -888,7 +900,7 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
             }
             // Bundles des Ziels (E69), unter den Einträgen: welche Links als Einheit zusammengehören.
             for (const bundle of zielZustand.bundles)
-                console.log(`  Bundle ${bundle.name}  (${quelleAlsText(bundle.quelle)})  ${bundle.skills.join(', ')}`);
+                console.log(`  Bundle ${bundle.name}  (${quelleAlsText(bundle.quelle)})  ${bundleLage(bundle)}`);
             if (zielZustand.plugins !== undefined)
                 console.log(`  Plugins: ${zielZustand.plugins.length === 0 ? 'keine' : zielZustand.plugins.join(', ')}`);
         }
@@ -1134,6 +1146,16 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
     }
     throw new Error(`Unbekanntes Kommando „${kommando}". hmgr --help zeigt alle Kommandos.`);
 }
+/**
+ * Lage eines installierten Bundles in einem Ziel (E114 L6), für `status` und `bundle list`:
+ * verlinkt von gesamt, die verlinkten Namen und, wenn etwas fehlt, was.
+ */
+function bundleLage(bundle) {
+    const gesamt = bundle.skills.length + bundle.nichtVerlinkt.length;
+    const verlinkt = bundle.skills.length === 0 ? '' : `  ${bundle.skills.join(', ')}`;
+    const fehlt = bundle.nichtVerlinkt.length === 0 ? '' : `  fehlt: ${bundle.nichtVerlinkt.join(', ')}`;
+    return `${bundle.skills.length}/${gesamt}${verlinkt}${fehlt}`;
+}
 /**
  * Bericht über den Bundle-Abgleich (E69), gleich für `hmgr bundle sync` und `hmgr update`: je
  * Bundle eine Zeile mit seinem Ausgang, darunter, was sich geändert hat. „fehlgeschlagen" heißt

package/dist/gui/main.js

@@ -174,6 +174,9 @@ function zielZustandSerialisieren(z) {
         bundles: z.bundles.map((b) => ({
             name: b.name,
             skills: b.skills,
+            // E114 L3: nicht verlinkte Mitglieder (herausgenommen oder von Hand gelöscht).
+            nichtVerlinkt: b.nichtVerlinkt,
+            herausgenommen: b.herausgenommen,
             quelleText: quelleAlsText(b.quelle),
             quelleName: quelleName(b.quelle),
         })),
@@ -234,8 +237,10 @@ function registriereIpc() {
         return ergebnis;
     }));
     // Bundles aller bekannten Quellen (E69): flach wie der Skill-Katalog, je Bundle seine Quelle und
-    // die Zahl seiner Mitglieder. Kaputte Definitionen kommen als eigene Liste mit, damit die GUI sie
-    // nennen kann, statt sie zu verschlucken.
+    // seine Mitglieder als Quelle plus Pfad (E114 L1). Name und Beschreibung eines Mitglieds sucht der
+    // Renderer im Skill-Katalog nach (`quelleSchluessel` + `pfad`): eine noch nicht eingerichtete
+    // Quelle wird hier nicht gelesen, sonst klonte jedes Öffnen des Dialogs. Kaputte Definitionen
+    // kommen als eigene Liste mit, damit die GUI sie nennen kann, statt sie zu verschlucken.
     ipcMain.handle('hmgr:bundles', async () => auffangen(async () => {
         const bundles = [];
         const kaputte = [];
@@ -244,7 +249,11 @@ function registriereIpc() {
                 bundles.push({
                     name: bundle.name,
                     beschreibung: bundle.beschreibung,
-                    mitglieder: bundle.mitglieder.length,
+                    mitglieder: bundle.mitglieder.map((m) => ({
+                        quelleSchluessel: quelleSchluessel(m.quelle),
+                        quelleText: quelleAlsText(m.quelle),
+                        pfad: m.pfad,
+                    })),
                     // Anzeige im Dialog: aus welchen Quellen das Bundle Skills holt, ohne Dubletten.
                     quellen: [...new Set(bundle.mitglieder.map((m) => quelleAlsText(m.quelle)))],
                     quelleText: quelleAlsText(bundle.quelle),
@@ -272,6 +281,24 @@ function registriereIpc() {
         };
     }));
     ipcMain.handle('hmgr:bundleEntfernen', async (_event, args) => auffangen(async () => anwendungsfaelle.bundleEntfernen({ bundle: args.bundle, ziel: zielAusIpc(args.harness, args.ort) })));
+    // Vervollständigen (E114 L4, `aufnehmen: 'alle'`) und „Wieder verlinken" einzelner Mitglieder (L3,
+    // Namensliste): der Abgleich dieses einen Bundles in diesem Ziel. Wie bundleEntfernen ohne Zeiger.
+    // Der Abgleich meldet einen Fehlschlag im Ergebnis statt zu werfen; hier wird er zum Fehler, damit
+    // `rufe` im Renderer ihn zeigt.
+    ipcMain.handle('hmgr:bundleAbgleichen', async (_event, args) => auffangen(async () => {
+        const eintraege = await anwendungsfaelle.bundleAbgleich({
+            bundle: args.bundle,
+            quelle: quelleAusText(args.quelleText),
+            ziel: zielAusIpc(args.harness, args.ort),
+            aufnehmen: args.aufnehmen,
+        });
+        const eintrag = eintraege[0];
+        if (eintrag === undefined)
+            throw new Error(`Bundle „${args.bundle}" ist dort nicht installiert.`);
+        if (eintrag.ergebnis === 'fehlgeschlagen')
+            throw new Error(`Bundle „${args.bundle}" ließ sich nicht vervollständigen: ${eintrag.fehler ?? ''}`);
+        return { gelegt: eintrag.gelegt };
+    }));
     // Nur die Herkunft, ohne die Quellen zu lesen: der Katalog daneben tut das schon.
     ipcMain.handle('hmgr:quellen', async () => auffangen(async () => (await anwendungsfaelle.quellen()).map((quelle) => ({
         art: quelle.art,
@@ -858,6 +885,7 @@ function fensterOeffnen() {
               // fällt, was ins Ziel kommt, und zeigt je Bundle Beschreibung und Herkunft.
               var dskBundleBoxSichtbar = false;
               var dskBundleText = null;
+              var dskBundleZuVorher = null, dskBundleKoerperText = null;
               // Aufklappbereich je Zeile (E92): zu vor dem Klick, danach sichtbar mit der ungekürzten
               // Beschreibung; die Checkbox bleibt unberührt, der Dialog offen.
               var dskKoerperVorher = null;
@@ -895,6 +923,13 @@ function fensterOeffnen() {
                 dskBundleBoxSichtbar = document.getElementById('dsk-bundlebox')?.hidden === false;
                 dskBundleText = document.querySelector('#dsk-bundles .wahlzeile')?.textContent
                   ?.replace(/\\s+/g, ' ').trim() ?? null;
+                // E114 L1: die Bundle-Wahlzeile klappt auf und zeigt ihre Skills samt Beschreibung.
+                var dskBundleKoerper = document.querySelector('#dsk-bundles .wahlzeile .wahlkoerper');
+                dskBundleZuVorher = dskBundleKoerper?.hidden ?? null;
+                document.querySelector('#dsk-bundles .wahlzeile .aufklappknopf')?.click();
+                dskBundleKoerperText = dskBundleKoerper && !dskBundleKoerper.hidden
+                  ? dskBundleKoerper.textContent?.replace(/\\s+/g, ' ').trim() ?? null
+                  : null;
                 document.getElementById('d-skills')?.close();
               }
               // Verlinken-Dialog „Wohin?" (E76): er bietet nur Ziele aktiver Harnesses an. Der Text
@@ -908,20 +943,33 @@ function fensterOeffnen() {
                   ?.replace(/\\s+/g, ' ').trim() ?? null;
                 document.getElementById('d-ziel')?.close();
               }
-              // Bundle-Gruppe an der Ziel-Karte (E69): Kopf mit Name, Quelle und Entfernen, darunter
-              // die Zeilen der Mitglieder — sie stehen in der Gruppe, nicht in der allgemeinen Liste.
-              var bundleGruppeText = document.querySelector('#zielliste .bundlegruppe .bundlekopf')?.textContent
+              // Bundle-Gruppe an der Claude-Code-Home-Karte (E69, E114): Kopf mit Name, Quelle, Zählung
+              // „1 von 2 Skills", „Vervollständigen" und „Entfernen"; darunter zugeklappt die Zeilen
+              // aller Mitglieder. „skill-creator" hat die Fixture herausgenommen, es steht als blasse
+              // Zeile „nicht verlinkt" mit „Wieder verlinken" in der Gruppe.
+              var homeGruppe = Array.from(document.querySelectorAll('#zielliste .ziel'))
+                .find((k) => (k.querySelector('.zielkopf')?.textContent || '').indexOf('Claude Code · Home') > -1)
+                ?.querySelector('.bundlegruppe') ?? null;
+              var bundleGruppeText = homeGruppe?.querySelector('.bundlekopf')?.textContent
                 ?.replace(/\\s+/g, ' ').trim() ?? null;
-              var bundleGruppeZeilen = Array.from(document.querySelectorAll('#zielliste .bundlegruppe .linkliste .name'))
+              var bundleGruppeZeilen = Array.from(homeGruppe?.querySelectorAll('.linkliste li:not(.nichtverlinkt) .name') ?? [])
                 .map((n) => n.textContent.trim()).join(',');
-              // Entfernen an der Einzelzeile innerhalb der Gruppe sagt, dass das Bundle zerbricht.
-              var bundleZerbrichtText = null;
+              var bundleNichtVerlinktText = homeGruppe?.querySelector('.linkliste li.nichtverlinkt')?.textContent
+                ?.replace(/\\s+/g, ' ').trim() ?? null;
+              var bundleVervollstaendigenKnopf = Array.from(homeGruppe?.querySelectorAll('.bundlekopf button') ?? [])
+                .some((k) => k.textContent === 'Vervollständigen');
+              var bundleKoerperZuVorher = homeGruppe?.querySelector('.linkliste')?.hidden ?? null;
+              homeGruppe?.querySelector('.bundlekopf .aufklappknopf')?.click();
+              var bundleKoerperAufNachKlick = homeGruppe?.querySelector('.linkliste')?.hidden === false;
+              // Entfernen an der Mitgliedszeile sagt, dass der Skill herausgenommen wird und das
+              // Bundle bleibt (E114 L2, früher: zerbricht).
+              var bundleHerausnehmenText = null;
               try {
-                document.querySelector('#zielliste .bundlegruppe .linkliste .knopf')?.click();
-                bundleZerbrichtText = document.getElementById('dx-text')?.textContent ?? null;
+                homeGruppe?.querySelector('.linkliste li:not(.nichtverlinkt) .knopf')?.click();
+                bundleHerausnehmenText = document.getElementById('dx-text')?.textContent ?? null;
                 document.querySelector('#d-entfernen button[value="nein"]')?.click();
               } catch (fehler) {
-                bundleZerbrichtText = String(fehler);
+                bundleHerausnehmenText = String(fehler);
               }
               // Sammelstreifen unter „Alle" (E95): das Bundle „vorhaben" liegt an kunde-x in Claude Code
               // und Hermes — ein Streifen mit beiden Harness-Zeichen, Entfernen nennt beide Harnesses
@@ -932,12 +980,21 @@ function fensterOeffnen() {
               var streifenZahl = null, streifenHarnesse = null, streifenText = null;
               var streifenDialogTitel = null, streifenDialogText = null;
               var chipGruppeZahl = null, chipGruppeZeilenZahl = null, chipStreifenZahl = null;
+              // E114 L1: unter „Alle" stehen die Mitglieder in der Gruppe und nicht zusätzlich in der
+              // Tabelle. Name ohne Harness-Zeichen: nur die Textknoten der Namenszelle.
+              var nurName = (n) => Array.from(n.childNodes).filter((t) => t.nodeType === 3).map((t) => t.textContent).join('').trim();
+              var alleGruppeZeilen = null, alleTabelleZeilen = null;
               try {
                 var streifen = Array.from(streifenKarte?.querySelectorAll('.bundlegruppe') ?? []);
                 streifenZahl = streifen.length;
                 streifenHarnesse = streifen[0]?.querySelector('.zeilenzeichen')?.getAttribute('aria-label') ?? null;
-                streifenText = streifen[0]?.textContent?.replace(/\\s+/g, ' ').trim() ?? null;
-                streifen[0]?.querySelector('button')?.click();
+                streifenText = streifen[0]?.querySelector('.bundlekopf')?.textContent?.replace(/\\s+/g, ' ').trim() ?? null;
+                alleGruppeZeilen = Array.from(streifen[0]?.querySelectorAll('.linkliste li .name') ?? []).map(nurName).join(',');
+                alleTabelleZeilen = Array.from(streifenKarte?.querySelectorAll('.linkliste li') ?? [])
+                  .filter((li) => li.closest('.bundlegruppe') === null && li.querySelector('.name'))
+                  .map((li) => nurName(li.querySelector('.name'))).join(',');
+                Array.from(streifen[0]?.querySelectorAll('.bundlekopf button') ?? [])
+                  .find((k) => k.textContent === 'Entfernen')?.click();
                 streifenDialogTitel = document.getElementById('dx-titel')?.textContent ?? null;
                 streifenDialogText = document.getElementById('dx-text')?.textContent ?? null;
                 document.querySelector('#d-entfernen button[value="nein"]')?.click();
@@ -1236,13 +1293,21 @@ function fensterOeffnen() {
                 dskAufklappFreiAngehakt,
                 dskBundleBoxSichtbar,
                 dskBundleText,
+                dskBundleZuVorher,
+                dskBundleKoerperText,
                 dzZieleText,
                 bundleGruppeText,
                 bundleGruppeZeilen,
-                bundleZerbrichtText,
+                bundleNichtVerlinktText,
+                bundleVervollstaendigenKnopf,
+                bundleKoerperZuVorher,
+                bundleKoerperAufNachKlick,
+                bundleHerausnehmenText,
                 streifenZahl,
                 streifenHarnesse,
                 streifenText,
+                alleGruppeZeilen,
+                alleTabelleZeilen,
                 streifenDialogTitel,
                 streifenDialogText,
                 chipGruppeZahl,

package/dist/gui/preload.cjs

@@ -15,6 +15,8 @@ contextBridge.exposeInMainWorld('hmgr', {
     bundles: () => ipcRenderer.invoke('hmgr:bundles'),
     bundleInstallieren: (args) => ipcRenderer.invoke('hmgr:bundleInstallieren', args),
     bundleEntfernen: (args) => ipcRenderer.invoke('hmgr:bundleEntfernen', args),
+    /** Vervollständigen ('alle') oder einzelne Mitglieder wieder verlinken (E114). */
+    bundleAbgleichen: (args) => ipcRenderer.invoke('hmgr:bundleAbgleichen', args),
     /** Icon einer Quelle als data-URL, oder null (E60). */
     icon: (text) => ipcRenderer.invoke('hmgr:icon', text),
     /** Öffnet eine Quelle: Repo-Seite im Browser oder Ordner im Dateimanager (E60). */

package/dist/gui/renderer/renderer.js

@@ -745,7 +745,7 @@
   }
 
   /** Eine Zeile der Link-Tabelle. `bundle` gesetzt heißt: die Zeile steht in einer Bundle-Gruppe
-      (E69), das Entfernen zerbricht dort das Bundle und der Dialog sagt es. */
+      (E69), das Entfernen nimmt den Skill dort aus dem Bundle heraus und der Dialog sagt es (E114). */
   function linkZeile(ei, z, bundle) {
     var name = ei.art === 'link' ? ei.link.name : ei.name;
     var li = e('li');
@@ -801,63 +801,156 @@
     return li;
   }
 
-  /** Ein installiertes Bundle als Gruppe über seinen Skill-Zeilen (E69, F68): Kopf mit Name, Quelle
-      und „Entfernen" für das Ganze, darunter die Zeilen seiner Mitglieder. */
-  function bundleGruppe(b, z, eintraege) {
+  /** Alle Mitglieder eines installierten Bundles in einem Ziel (E114 L3): verlinkte und nicht
+      verlinkte, aus dem Zustand — ohne die Definition, die Gruppe steht auch bei fehlender Quelle. */
+  function bundleAlleMitglieder(b) {
+    return b.skills.concat(b.nichtVerlinkt || []);
+  }
+
+  /** Skill zu einem Mitglied einer Definition aus dem Skill-Katalog (E114 L1): gleiche Quelle, gleicher
+      Pfad. null, wenn die Quelle (noch) nicht eingerichtet oder nicht lesbar ist. */
+  function bundleMitgliedSkill(m) {
+    return SKILLS.filter(function (s) { return s.quelleSchluessel === m.quelleSchluessel && s.pfad === m.pfad; })[0] || null;
+  }
+
+  /** Skill eines nicht verlinkten Mitglieds über seinen Namen, gesucht unter den Mitgliedern der
+      Definition (Name plus Quelle des Bundles). null, wenn sich das nicht auflösen lässt. */
+  function bundleSkillNachName(b, name) {
+    var katalog = BUNDLES.filter(function (k) { return k.name === b.name && k.quelleText === b.quelleText; })[0];
+    if (!katalog) return null;
+    for (var i = 0; i < katalog.mitglieder.length; i++) {
+      var skill = bundleMitgliedSkill(katalog.mitglieder[i]);
+      if (skill && skill.name === name) return skill;
+    }
+    return null;
+  }
+
+  /** Vervollständigen (E114 L4, `aufnehmen` 'alle') oder Wieder verlinken (L3, Namensliste) eines
+      Bundles in den genannten Zielen. Ein Fehlschlag in einem Ziel hält die übrigen nicht auf,
+      `rufe` meldet ihn selbst. */
+  async function bundleAufnehmen(b, ziele, aufnehmen) {
+    var gelegt = 0;
+    var gescheitert = 0;
+    for (var i = 0; i < ziele.length; i++) {
+      var ziel = ziele[i];
+      try {
+        var ergebnis = await rufe(function () {
+          return window.hmgr.bundleAbgleichen({
+            bundle: b.name, quelleText: b.quelleText, harness: ziel.harness, ort: ziel.ort, aufnehmen: aufnehmen,
+          });
+        });
+        gelegt += ergebnis.gelegt.length;
+      } catch (fehler) {
+        gescheitert++;
+      }
+    }
+    await ladeAlles();
+    if (gescheitert === 0) melde('Bundle ' + b.name + ': ' + zahlwort(gelegt, 'Link', 'Links') + ' gelegt.');
+  }
+
+  // Aufklappzustand der Bundle-Gruppen (E114 L1), überlebt den Neuaufbau durch ladeAlles wie
+  // SKILL_OFFEN. Zu Beginn sind die Gruppen zugeklappt.
+  var BUNDLE_OFFEN = {};
+  var bundleKoerperNr = 0;
+
+  /** Rahmen einer Bundle-Gruppe (E69, E114 L1/L3/L4): Kopf mit Name, Quelle, „x von N Skills",
+      „Vervollständigen", wenn etwas fehlt, und „Entfernen" für das Ganze; darunter aufklappbar die
+      Zeilen aller Mitglieder. `harnesse` nur unter „Alle" (Harness-Zeichen am Kopf, E95). */
+  function bundleRahmen(b, harnesse, verlinkt, gesamt, ziele, zeilen, entfernen, schluessel) {
     var gruppe = e('div', 'bundlegruppe');
     var kopf = e('div', 'bundlekopf');
     var titel = e('span', 'bundletitel');
+    if (harnesse) titel.appendChild(harnesseZeichenSammel(harnesse));
     titel.appendChild(e('span', 'etikett', 'Bundle'));
     titel.appendChild(e('b', 'bundlename', b.name));
     kopf.appendChild(titel);
     var quelleEl = e('span', 'mono bundlequelle', b.quelleName);
     quelleEl.title = b.quelleText;
     kopf.appendChild(quelleEl);
-    kopf.appendChild(e('span', 'bundlezahl', zahlwort(b.skills.length, 'Skill', 'Skills')));
+    kopf.appendChild(e('span', 'bundlezahl', verlinkt === gesamt
+      ? zahlwort(gesamt, 'Skill', 'Skills')
+      : verlinkt + ' von ' + zahlwort(gesamt, 'Skill', 'Skills')));
+    var aktionen = e('span', 'bundleaktionen');
+    if (verlinkt < gesamt) {
+      var voll = e('button', 'knopf leise klein', 'Vervollständigen');
+      voll.type = 'button';
+      voll.setAttribute('aria-label', 'Bundle ' + b.name + ' vervollständigen: alle fehlenden Skills verlinken');
+      voll.addEventListener('click', function () { bundleAufnehmen(b, ziele, 'alle'); });
+      aktionen.appendChild(voll);
+    }
     var weg = e('button', 'knopf leise klein', 'Entfernen');
     weg.type = 'button';
-    weg.setAttribute('aria-label', 'Bundle ' + b.name + ' aus ' + zielTitel(z) + ' entfernen');
-    weg.addEventListener('click', function () { frageBundleEntfernen(b, z.ziel); });
-    kopf.appendChild(weg);
+    weg.setAttribute('aria-label', 'Bundle ' + b.name + ' entfernen');
+    weg.addEventListener('click', entfernen);
+    aktionen.appendChild(weg);
+    var offen = !!BUNDLE_OFFEN[schluessel];
+    var koerperId = 'bundlekoerper-' + bundleKoerperNr++;
+    var umschalter = e('button', 'aufklappknopf');
+    umschalter.type = 'button';
+    umschalter.setAttribute('aria-expanded', offen ? 'true' : 'false');
+    umschalter.setAttribute('aria-controls', koerperId);
+    umschalter.setAttribute('aria-label', 'Skills des Bundles ' + b.name + ' ein- oder ausklappen');
+    var pfeil = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
+    pfeil.setAttribute('viewBox', '0 0 16 16');
+    pfeil.setAttribute('class', 'akkordeonpfeil dunkel');
+    pfeil.setAttribute('aria-hidden', 'true');
+    pfeil.innerHTML = '<path d="M4 6.5 8 10.5 12 6.5"/>';
+    umschalter.appendChild(pfeil);
+    aktionen.appendChild(umschalter);
+    kopf.appendChild(aktionen);
     gruppe.appendChild(kopf);
     var ul = e('ul', 'linkliste');
-    eintraege.forEach(function (ei) { ul.appendChild(linkZeile(ei, z, b)); });
+    ul.id = koerperId;
+    ul.hidden = !offen;
+    zeilen.forEach(function (li) { ul.appendChild(li); });
     gruppe.appendChild(ul);
+    function schalte() {
+      offen = !offen;
+      BUNDLE_OFFEN[schluessel] = offen;
+      umschalter.setAttribute('aria-expanded', offen ? 'true' : 'false');
+      ul.hidden = !offen;
+    }
+    umschalter.addEventListener('click', schalte);
+    // Der Kopf schaltet mit, außer über seine Knöpfe (wie der Kopf einer Ziel-Karte).
+    kopf.addEventListener('click', function (ev) {
+      if (ev.target.closest('button, a') === null) schalte();
+    });
     return gruppe;
   }
 
-  /** Ein Bundle als einzelner Streifen (Chip „Alle" einer Verzeichnis-Karte, E69/E53/E95): die
-      Harness-Zeichen aller Harnesses, in denen es liegt (wie in den Skill-Zeilen), Name, Mitglieder,
-      Entfernen für alle diese Harnesses. `treffer`: [{b, z}], je Harness einer, gleicher Name und
-      gleiche Quelle. Mitglieder: die des ersten Treffers, abweichende anderer Harnesses folgen. */
-  function bundleStreifen(treffer) {
-    var b = treffer[0].b;
-    var streifen = e('div', 'bundlegruppe');
-    var kopf = e('div', 'bundlekopf');
-    var titel = e('span', 'bundletitel');
-    var harnesse = [];
-    treffer.forEach(function (t) { if (harnesse.indexOf(t.z.ziel.harness) === -1) harnesse.push(t.z.ziel.harness); });
-    harnesse.sort(function (x, y) { return harnessName(x).localeCompare(harnessName(y), 'de'); });
-    titel.appendChild(harnesseZeichenSammel(harnesse));
-    titel.appendChild(e('span', 'etikett', 'Bundle'));
-    titel.appendChild(e('b', 'bundlename', b.name));
-    kopf.appendChild(titel);
-    var mitglieder = [];
-    treffer.forEach(function (t) {
-      t.b.skills.forEach(function (n) { if (mitglieder.indexOf(n) === -1) mitglieder.push(n); });
-    });
-    kopf.appendChild(e('span', 'bundlemitglieder', mitglieder.join(', ')));
-    var weg = e('button', 'knopf leise klein', 'Entfernen');
-    weg.type = 'button';
-    weg.setAttribute('aria-label', 'Bundle ' + b.name + ' aus '
-      + treffer.map(function (t) { return zielTitel(t.z); }).join(', ') + ' entfernen');
-    weg.addEventListener('click', function () {
-      if (treffer.length === 1) frageBundleEntfernen(b, treffer[0].z.ziel);
-      else frageBundleEntfernenAlle(b.name, mitglieder, treffer);
+  /** Zeile eines nicht verlinkten Mitglieds (E114 L3): blass, „nicht verlinkt", „Wieder verlinken".
+      `skill` aus dem Katalog oder null, wenn die Definition oder Quelle nicht lesbar ist. */
+  function nichtVerlinktZeile(name, skill, wiederVerlinken) {
+    var li = e('li', 'nichtverlinkt');
+    li.appendChild(e('span'));
+    li.appendChild(e('span', 'name', name));
+    if (skill) li.appendChild(wasZelle(skill));
+    else {
+      var feld = e('span', 'wasfeld');
+      feld.appendChild(e('span', 'was fehlt', 'Beschreibung nicht lesbar, die Quelle fehlt hier'));
+      li.appendChild(feld);
+    }
+    li.appendChild(e('span', 'quelle', 'nicht verlinkt'));
+    var knopf = e('button', 'knopf leise klein', 'Wieder verlinken');
+    knopf.type = 'button';
+    knopf.setAttribute('aria-label', name + ' wieder verlinken');
+    knopf.addEventListener('click', wiederVerlinken);
+    li.appendChild(knopf);
+    return li;
+  }
+
+  /** Ein installiertes Bundle unter dem Harness-Chip (E69, E114): alle Mitglieder in der Gruppe,
+      verlinkte als gewöhnliche Link-Zeilen, nicht verlinkte blass mit „Wieder verlinken". */
+  function bundleGruppe(b, z, eintraege) {
+    var zeilen = eintraege.map(function (ei) { return linkZeile(ei, z, b); });
+    (b.nichtVerlinkt || []).slice().sort(function (x, y) { return x.localeCompare(y, 'de'); }).forEach(function (name) {
+      zeilen.push(nichtVerlinktZeile(name, bundleSkillNachName(b, name), function () {
+        bundleAufnehmen(b, [z.ziel], [name]);
+      }));
     });
-    kopf.appendChild(weg);
-    streifen.appendChild(kopf);
-    return streifen;
+    return bundleRahmen(b, null, b.skills.length, bundleAlleMitglieder(b).length, [z.ziel], zeilen, function () {
+      frageBundleEntfernen(b, z.ziel);
+    }, 'ziel\u0000' + zielKey(z.ziel) + '\u0000' + b.name + '\u0000' + b.quelleText);
   }
 
   function linkTeil(z) {
@@ -881,8 +974,13 @@
       }
     }
 
+    // Bundles zuerst (E69): sie stehen als Gruppe über den Einzel-Zeilen, ihre Mitglieder liegen
+    // in der Gruppe statt in der allgemeinen Liste. Was zum Bundle gehört, sagt der Kern. Eine Gruppe
+    // steht auch, wenn kein Mitglied mehr verlinkt ist („0 von N", E114).
+    var bundles = (z.bundles || []).filter(function (b) { return bundleAlleMitglieder(b).length > 0; });
+
     var fussContainer;
-    if (eigene.length === 0) {
+    if (eigene.length === 0 && bundles.length === 0) {
       var leer = e('div', 'leerzeile');
       leer.appendChild(e('p', 'ohne', 'Hier liegt noch nichts.'));
       teil.appendChild(leer);
@@ -898,9 +996,6 @@
       kopf.appendChild(e('span'));
       teil.appendChild(kopf);
 
-      // Bundles zuerst (E69): sie stehen als Gruppe über den Einzel-Zeilen, ihre Mitglieder liegen
-      // in der Gruppe statt in der allgemeinen Liste. Was zum Bundle gehört, sagt der Kern.
-      var bundles = (z.bundles || []).filter(function (b) { return b.skills.length > 0; });
       var bundleVon = {};
       bundles.forEach(function (b) { b.skills.forEach(function (n) { bundleVon[n] = b; }); });
       bundles
@@ -931,7 +1026,7 @@
 
     // Ohne eigene Links (leer-Fall) steht der MCP-Abschnitt hinter der Leerzeile, die dort schon den
     // Kartenfuß bildet (Nachricht + Knöpfe in einer Zeile, wie überall sonst im leeren Zustand).
-    if (eigene.length === 0) {
+    if (eigene.length === 0 && bundles.length === 0) {
       var mcpAbschnOhneTabelle = mcpAbschnitt(z.ziel);
       if (mcpAbschnOhneTabelle) teil.appendChild(mcpAbschnOhneTabelle);
     }
@@ -1220,7 +1315,37 @@
       verzMcpZiele.push(z);
     });
 
-    if (reihenfolge.length === 0) {
+    // Bundles unter „Alle" (E69, E95, E114 L1): eine aufklappbare Gruppe je Bundle, wie unter dem
+    // Harness-Chip, aber über alle Harnesses am Ort zusammengefasst: Schlüssel ist Name plus Quelle,
+    // gleichnamige Bundles aus zwei Quellen bleiben getrennt. Eine Gruppe steht auch, wenn kein
+    // Mitglied mehr verlinkt ist („0 von N").
+    var bundleGruppen = {}, bundleReihenfolge = [];
+    teile.forEach(function (z) {
+      (z.bundles || [])
+        .filter(function (b) { return bundleAlleMitglieder(b).length > 0; })
+        .forEach(function (b) {
+          var schluessel = b.name + '\u0000' + b.quelleText;
+          if (!bundleGruppen[schluessel]) { bundleGruppen[schluessel] = []; bundleReihenfolge.push(schluessel); }
+          bundleGruppen[schluessel].push({ b: b, z: z });
+        });
+    });
+    // Eine Tabellenzeile geht in einer Gruppe auf, wenn ihr Name in JEDEM Harness der Zeile ein
+    // verlinktes Mitglied dieses Bundles ist — dann steht sie nur in der Gruppe, nicht zusätzlich in
+    // der Tabelle (E114 L1). Hängt derselbe Skill in einem Harness als Einzel-Link, bleibt die
+    // Zeile in der Tabelle. Die Zählung im Kartenkopf (E71) bleibt davon unberührt.
+    var zeileInGruppe = {};
+    reihenfolge.forEach(function (key) {
+      var row = zeilen[key];
+      bundleReihenfolge.forEach(function (gk) {
+        if (zeileInGruppe[key]) return;
+        var ganz = row.teile.every(function (z) {
+          return bundleGruppen[gk].some(function (t) { return t.z === z && t.b.skills.indexOf(row.name) > -1; });
+        });
+        if (ganz) zeileInGruppe[key] = gk;
+      });
+    });
+
+    if (reihenfolge.length === 0 && bundleReihenfolge.length === 0) {
       var leer = e('div', 'leerzeile');
       leer.appendChild(e('p', 'ohne', 'Hier liegt noch nichts.'));
       leer.appendChild(alleSkillsKnopf(pfad, teile));
@@ -1236,27 +1361,6 @@
       return teil;
     }
 
-    // Bundles unter „Alle" (E69): die Zeilen bleiben nach Name und Quelle gebündelt (E53), ein
-    // Bundle gehört aber zu genau einem Harness — deshalb hier ein Streifen je Bundle mit seinem
-    // Harness-Zeichen statt einer Umgruppierung der Tabelle. Unter dem Harness-Chip zeigt linkTeil
-    // die volle Gruppe über den Zeilen.
-    // Ein Bundle, das in mehreren Harnesses am selben Ort liegt, ist hier ein Streifen (E95), wie
-    // die Skill-Zeilen: Schlüssel ist Name plus Quelle, gleichnamige Bundles aus zwei Quellen
-    // bleiben getrennt.
-    var bundleGruppen = {}, bundleReihenfolge = [];
-    teile.forEach(function (z) {
-      (z.bundles || [])
-        .filter(function (b) { return b.skills.length > 0; })
-        .forEach(function (b) {
-          var schluessel = b.name + '\u0000' + b.quelleText;
-          if (!bundleGruppen[schluessel]) { bundleGruppen[schluessel] = []; bundleReihenfolge.push(schluessel); }
-          bundleGruppen[schluessel].push({ b: b, z: z });
-        });
-    });
-    bundleReihenfolge
-      .sort(function (a, b) { return bundleGruppen[a][0].b.name.localeCompare(bundleGruppen[b][0].b.name, 'de'); })
-      .forEach(function (k) { teil.appendChild(bundleStreifen(bundleGruppen[k])); });
-
     var kopf = e('div', 'linkkopf');
     kopf.appendChild(e('span'));
     kopf.appendChild(e('span', 'etikett', 'Skill'));
@@ -1265,16 +1369,17 @@
     kopf.appendChild(e('span'));
     teil.appendChild(kopf);
 
-    var ul = e('ul', 'linkliste');
-    reihenfolge
+    var sortiert = reihenfolge
       .slice()
       .sort(function (ka, kb) {
         var a = zeilen[ka], b = zeilen[kb];
         if (a.defekt !== b.defekt) return a.defekt ? -1 : 1;
         return a.name.localeCompare(b.name, 'de');
-      })
-      .forEach(function (key) {
-        var row = zeilen[key];
+      });
+
+    /** Eine gebündelte Zeile unter „Alle" (E53). `bundleName` gesetzt: sie steht in einer
+        Bundle-Gruppe, das Entfernen nimmt den Skill dort heraus (E114). */
+    function alleZeile(row, bundleName) {
         var harnesse = [];
         row.teile.forEach(function (z) { if (harnesse.indexOf(z.ziel.harness) === -1) harnesse.push(z.ziel.harness); });
         harnesse.sort(function (a, b) { return harnessName(a).localeCompare(harnessName(b), 'de'); });
@@ -1325,14 +1430,64 @@
           // Namens nebeneinander, sobald ein Skill je Harness aus verschiedener Quelle hängt.
           weg.setAttribute('aria-label', 'Link auf ' + row.name + ' in '
             + entfernbar.map(function (z) { return harnessName(z.ziel.harness); }).join(', ') + ' entfernen');
-          weg.addEventListener('click', function () { frageEntfernenAlle(row.name, pfad, entfernbar, nichtEntfernbar); });
+          weg.addEventListener('click', function () {
+            frageEntfernenAlle(row.name, pfad, entfernbar, nichtEntfernbar, bundleName);
+          });
           li.appendChild(weg);
         } else {
           li.appendChild(e('span', 'kein-weg', 'nur über Plugin „' + pluginNamen.join('“, „') + '“'));
         }
-        ul.appendChild(li);
+        return li;
+    }
+
+    // Erst die Bundle-Gruppen, darunter die übrigen Zeilen (wie unter dem Harness-Chip, E69).
+    bundleReihenfolge
+      .sort(function (a, b) { return bundleGruppen[a][0].b.name.localeCompare(bundleGruppen[b][0].b.name, 'de'); })
+      .forEach(function (gk) {
+        var treffer = bundleGruppen[gk];
+        var b = treffer[0].b;
+        var harnesse = [];
+        treffer.forEach(function (t) { if (harnesse.indexOf(t.z.ziel.harness) === -1) harnesse.push(t.z.ziel.harness); });
+        harnesse.sort(function (x, y) { return harnessName(x).localeCompare(harnessName(y), 'de'); });
+        // Mitglieder über alle Harnesses ohne Doppelte; verlinkt zählt, was in jedem Harness liegt.
+        var mitglieder = [];
+        treffer.forEach(function (t) {
+          bundleAlleMitglieder(t.b).forEach(function (n) { if (mitglieder.indexOf(n) === -1) mitglieder.push(n); });
+        });
+        var ueberall = mitglieder.filter(function (n) {
+          return treffer.every(function (t) { return t.b.skills.indexOf(n) > -1; });
+        });
+        var gruppenZeilen = sortiert
+          .filter(function (key) { return zeileInGruppe[key] === gk; })
+          .map(function (key) { return alleZeile(zeilen[key], b.name); });
+        // Nirgends verlinkte Mitglieder als blasse Zeile; „Wieder verlinken" in jedem Harness, in
+        // dem das Mitglied fehlt.
+        mitglieder
+          .filter(function (n) { return treffer.every(function (t) { return t.b.skills.indexOf(n) === -1; }); })
+          .sort(function (x, y) { return x.localeCompare(y, 'de'); })
+          .forEach(function (n) {
+            gruppenZeilen.push(nichtVerlinktZeile(n, bundleSkillNachName(b, n), function () {
+              bundleAufnehmen(b, treffer
+                .filter(function (t) { return (t.b.nichtVerlinkt || []).indexOf(n) > -1; })
+                .map(function (t) { return t.z.ziel; }), [n]);
+            }));
+          });
+        var verlinkteNamen = [];
+        treffer.forEach(function (t) {
+          t.b.skills.forEach(function (n) { if (verlinkteNamen.indexOf(n) === -1) verlinkteNamen.push(n); });
+        });
+        teil.appendChild(bundleRahmen(b, harnesse, ueberall.length, mitglieder.length,
+          treffer.map(function (t) { return t.z.ziel; }), gruppenZeilen, function () {
+            if (treffer.length === 1) frageBundleEntfernen(b, treffer[0].z.ziel);
+            else frageBundleEntfernenAlle(b.name, verlinkteNamen, treffer);
+          }, 'verz\u0000' + pfad + '\u0000' + gk));
       });
-    teil.appendChild(ul);
+
+    var ul = e('ul', 'linkliste');
+    sortiert
+      .filter(function (key) { return !zeileInGruppe[key]; })
+      .forEach(function (key) { ul.appendChild(alleZeile(zeilen[key], null)); });
+    if (ul.childNodes.length > 0) teil.appendChild(ul);
 
     // MCP-Abschnitt (E61-GUI-Nachtrag): auf Kartenebene unter „Alle", wie unter dem Harness-Chip,
     // der an diesem Pfad MCP kann.
@@ -1638,28 +1793,42 @@
   // entfernenKontext.eintraege: [{harness, ort}], immer eines bei frageEntfernen (Einzel-Ziel),
   // mehrere bei frageEntfernenAlle (E53 Pkt. 2, „Alle"-Zeile über mehrere Harnesses).
   var entfernenKontext = null;
-  /** `bundleName` gesetzt heißt: der Link gehört zu einem Bundle, das Entfernen zerbricht es (E69). */
+  /** Satz für den Entfernen-Dialog einer Zeile in einer Bundle-Gruppe (E114 L2): das Bundle bleibt. */
+  function herausnehmenSatz(bundleName) {
+    return ' Der Skill wird damit aus dem Bundle „' + bundleName + '“ herausgenommen: das Bundle bleibt, '
+      + 'das Aktualisieren legt den Link nicht wieder an. „Wieder verlinken“ oder „Vervollständigen“ am Bundle holt ihn zurück.';
+  }
+
+  /** `bundleName` gesetzt heißt: der Link gehört zu einem Bundle, das Entfernen nimmt ihn dort
+      heraus (E114, früher Zerbrechen nach E69). */
   function frageEntfernen(name, ziel, bundleName) {
     entfernenKontext = { art: 'link', name: name, eintraege: [{ harness: ziel.harness, ort: ziel.ort }] };
     $('dx-titel').textContent = 'Link auf ' + name + ' entfernen?';
     var text = 'Der Link in ' + zielTitel({ ziel: ziel }) + ' verschwindet. Der Checkout bleibt liegen, bis kein Link mehr darauf zeigt.';
-    if (bundleName) {
-      text += ' Damit zerbricht das Bundle „' + bundleName + '“ hier: seine übrigen Links bleiben liegen, aber nicht mehr als Bundle.';
-    }
+    if (bundleName) text += herausnehmenSatz(bundleName);
     $('dx-text').textContent = text;
     zeige($('d-entfernen'));
   }
 
-  /** Entfernen des ganzen Bundles an einem Ziel (E69): alle seine Links auf einmal. */
+  /** Zusatz für die Bundle-Dialoge (E114): was schon nicht mehr verlinkt ist, bleibt unberührt. */
+  function nichtVerlinktSatz(namen) {
+    return namen.length === 0 ? '' : ' Nicht verlinkt sind schon: ' + namen.join(', ') + '.';
+  }
+
+  /** Entfernen des ganzen Bundles an einem Ziel (E69, E114 L2): alle noch verlinkten Mitglieder auf
+      einmal, auch nach Teil-Löschung. */
   function frageBundleEntfernen(b, ziel) {
     entfernenKontext = { art: 'bundle', bundle: b.name, ziele: [ziel] };
     $('dx-titel').textContent = 'Bundle ' + b.name + ' entfernen?';
-    $('dx-text').textContent = zahlwort(b.skills.length, 'Link', 'Links') + ' aus ' + zielTitel({ ziel: ziel })
-      + ' verschwinden: ' + b.skills.join(', ') + '. Die Checkouts bleiben liegen, bis kein Link mehr darauf zeigt.';
+    $('dx-text').textContent = (b.skills.length === 0
+      ? 'Kein Link mehr da, aus ' + zielTitel({ ziel: ziel }) + ' verschwindet nur der Bundle-Verweis.'
+      : zahlwort(b.skills.length, 'Link', 'Links') + ' aus ' + zielTitel({ ziel: ziel })
+        + ' verschwinden: ' + b.skills.join(', ') + '. Die Checkouts bleiben liegen, bis kein Link mehr darauf zeigt.')
+      + nichtVerlinktSatz(b.nichtVerlinkt || []);
     zeige($('d-entfernen'));
   }
-  /** Entfernen eines Bundles in allen Harnesses seines Streifens (E95): `treffer` wie bei
-      bundleStreifen, der Dialog nennt die Harnesses mit ihrer Linkzahl und die Mitglieder. */
+  /** Entfernen eines Bundles in allen Harnesses seiner Gruppe unter „Alle" (E95): `treffer` je
+      Harness {b, z}, der Dialog nennt die Harnesses mit ihrer Linkzahl und die verlinkten Mitglieder. */
   function frageBundleEntfernenAlle(name, mitglieder, treffer) {
     entfernenKontext = { art: 'bundle', bundle: name, ziele: treffer.map(function (t) { return t.z.ziel; }) };
     var proHarness = treffer.map(function (t) {
@@ -1667,13 +1836,15 @@
     });
     $('dx-titel').textContent = 'Bundle ' + name + ' entfernen?';
     $('dx-text').textContent = 'Das Bundle verschwindet in ' + treffer.length + ' Harnesses (' + proHarness.join(', ')
-      + '): ' + mitglieder.join(', ') + '. Die Checkouts bleiben liegen, bis kein Link mehr darauf zeigt.';
+      + ')' + (mitglieder.length === 0 ? '.' : ': ' + mitglieder.join(', ') + '.')
+      + ' Die Checkouts bleiben liegen, bis kein Link mehr darauf zeigt.';
     zeige($('d-entfernen'));
   }
   /** Entfernen einer „Alle"-Zeile (E53 Pkt. 2): entfernbareZiele sind die Ziele (voller z.ziel), in
       denen der Link weg soll, nichtEntfernbareHarnesse die, in denen er nur über ein Plugin hängt
-      und liegen bleibt. Der Dialog nennt beides. */
-  function frageEntfernenAlle(name, pfad, entfernbareZiele, nichtEntfernbareHarnesse) {
+      und liegen bleibt. Der Dialog nennt beides. `bundleName` gesetzt: die Zeile steht in einer
+      Bundle-Gruppe, der Skill wird dort herausgenommen (E114). */
+  function frageEntfernenAlle(name, pfad, entfernbareZiele, nichtEntfernbareHarnesse, bundleName) {
     entfernenKontext = {
       art: 'link',
       name: name,
@@ -1686,6 +1857,7 @@
       text += ' In ' + nichtEntfernbareHarnesse.map(harnessName).join(', ') + ' bleibt er bestehen (nur über das Plugin).';
     }
     text += ' Der Checkout bleibt liegen, bis kein Link mehr darauf zeigt.';
+    if (bundleName) text += herausnehmenSatz(bundleName);
     $('dx-text').textContent = text;
     zeige($('d-entfernen'));
   }
@@ -2328,13 +2500,14 @@
       var txt = e('span');
       txt.appendChild(e('b', null, bundle.name));
       txt.appendChild(e('span', 'notiz', bundle.beschreibung));
-      var herkunft = e('span', 'mono', zahlwort(bundle.mitglieder, 'Skill', 'Skills')
+      var herkunft = e('span', 'mono', zahlwort(bundle.mitglieder.length, 'Skill', 'Skills')
         + ' aus ' + zahlwort(bundle.quellen.length, 'Quelle', 'Quellen') + ' · ' + bundle.quelleName);
       herkunft.title = bundle.quellen.join('\n');
       txt.appendChild(herkunft);
       if (ueberall) txt.appendChild(e('span', 'notiz', zieleZahl > 1 ? 'Hängt schon überall.' : 'Hängt hier schon.'));
       else if (schon > 0) txt.appendChild(e('span', 'notiz', 'Hängt schon in ' + schon + ' von ' + zieleZahl + ' Harnesses.'));
       label.appendChild(txt);
+      bundleAufklappbereich(bundle, label, txt, i);
       box.appendChild(label);
     });
     $('dsk-bundlebox').hidden = BUNDLES.length === 0 && BUNDLES_KAPUTT.length === 0;
@@ -2346,6 +2519,54 @@
     }).join('\n');
   }
 
+  /** Aufklappbereich einer Bundle-Wahlzeile (E114 L1, F133=O3): die Skills des Bundles mit ihrer
+      Beschreibung, vor der Installation. Muster und Verhalten wie skillAufklappbereich (E92): Knopf
+      oben rechts am Label, Körper als eigenes Grid-Kind, preventDefault gegen das Umschalten der
+      Checkbox, je Dialog-Öffnung zugeklappt. Name und Beschreibung kommen aus dem Skill-Katalog;
+      liegt ein Mitglied in einer noch nicht eingerichteten Quelle, steht dort sein Pfad. */
+  function bundleAufklappbereich(bundle, label, txt, index) {
+    var koerperId = 'dsk-bundlekoerper-' + index;
+    var knopf = e('button', 'aufklappknopf');
+    knopf.type = 'button';
+    knopf.setAttribute('aria-expanded', 'false');
+    knopf.setAttribute('aria-controls', koerperId);
+    knopf.setAttribute('aria-label', 'Skills des Bundles ' + bundle.name + ' ein- oder ausklappen');
+    var pfeil = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
+    pfeil.setAttribute('viewBox', '0 0 16 16');
+    pfeil.setAttribute('class', 'akkordeonpfeil dunkel');
+    pfeil.setAttribute('aria-hidden', 'true');
+    pfeil.innerHTML = '<path d="M4 6.5 8 10.5 12 6.5"/>';
+    knopf.appendChild(pfeil);
+
+    var koerper = e('div', 'wahlkoerper');
+    koerper.id = koerperId;
+    koerper.hidden = true;
+    bundle.mitglieder.forEach(function (m) {
+      var skill = bundleMitgliedSkill(m);
+      var zeile = e('p', 'skilldetail bundlemitglied');
+      if (skill) {
+        zeile.appendChild(e('b', null, skill.name + ': '));
+        zeile.appendChild(document.createTextNode(skill.beschreibung || 'keine Beschreibung in der SKILL.md'));
+      } else {
+        zeile.appendChild(e('b', null, m.pfad + ': '));
+        zeile.appendChild(document.createTextNode('aus ' + m.quelleText + ', die Quelle ist hier noch nicht eingerichtet'));
+      }
+      koerper.appendChild(zeile);
+    });
+
+    knopf.addEventListener('click', function (ev) {
+      ev.preventDefault();
+      var war = knopf.getAttribute('aria-expanded') === 'true';
+      knopf.setAttribute('aria-expanded', war ? 'false' : 'true');
+      koerper.hidden = war;
+    });
+    koerper.addEventListener('click', function (ev) { ev.preventDefault(); });
+
+    txt.classList.add('mitknopf');
+    label.appendChild(knopf);
+    label.appendChild(koerper);
+  }
+
   /** Wie oft ein Bundle in den angesteuerten Zielen schon installiert ist (Name plus Quelle, E69). */
   function bundleHaengtIn(teile, bundle) {
     return teile.filter(function (z) {

package/dist/gui/renderer/styles.css

@@ -798,6 +798,14 @@ dialog::backdrop{background:rgba(9,45,37,.62)}
 .bundlemitglieder{font-family:var(--mono);font-size:16px;letter-spacing:-.012em;color:var(--tinte-weich)}
 .bundlekopf .knopf{margin-left:auto}
 .bundlegruppe .linkliste li:last-child{border-bottom:1px solid var(--strich-zart)}
+/* E114: Knöpfe und Aufklapp-Umschalter rechts im Kopf; der Kopf ist zugleich Klickfläche. */
+.bundlekopf{cursor:pointer}
+.bundleaktionen{margin-left:auto;display:inline-flex;align-items:center;gap:8px}
+.bundleaktionen .knopf{margin-left:0}
+.bundlegruppe .linkliste[hidden]{display:none}
+/* Nicht verlinktes Mitglied (E114 L3): blass, der Knopf bleibt lesbar. */
+.linkliste li.nichtverlinkt .name,.linkliste li.nichtverlinkt .was{color:var(--tinte-leise)}
+.linkliste li.nichtverlinkt .quelle{color:var(--tinte-leise);font-style:italic}
 
 /* Bundle- und Skill-Sektion im Dialog „Skills hinzufügen" (E69): zwei benannte Gruppen unter
    demselben Suchfeld. */

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.45",
+  "version": "0.0.46",
   "description": "Harness Manager: Skills und Plugins für AI-Harnesses verwalten",
   "license": "MIT",
   "author": "Tim Kaufmann",