hmgr 0.0.6 → 0.0.7

package/dist/cli/main.js

@@ -4,8 +4,8 @@ import path from 'node:path';
 import { realpathSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { pathToFileURL } from 'node:url';
-import { Anwendungsfaelle } from "../kern/anwendungsfaelle.js";
-import { AbhaengigkeitFehlt, EinschraenkungOhneZeiger, HarnessNichtVorhanden, HarnessTypUnbekannt, KeinPassenderRef, LinkAnlegenFehlgeschlagen, McpAbweichenderEintrag, McpEbeneNichtUnterstuetzt, McpFaehigkeitFehlt, McpKatalogFehler, McpNichtInGeteilterDatei, McpNurGeteilterFundort, McpUebernahmeNichtMoeglich, McpUebernahmeUnvollstaendig, McpUnbekannt, NameBelegt, OrtNichtUnterstuetzt, PluginMehrdeutig, PluginUnbekannt, QuelleAufraeumenLokaleAenderungen, QuelleNameBelegt, QuelleUnbekannt, SkillMehrdeutig, SkillOrdnerBereitsVerwaltet, SkillOrdnerFaehigkeitFehlt, SkillOrdnerNichtVerwaltet, SkillOrdnerUngueltig, SkillUnbekannt, ZeigerMehrdeutig, ZeigerSchreibenGesperrt, pluginSchluessel, quelleName, quelleSchluessel, } from "../kern/modell.js";
+import { Anwendungsfaelle, } from "../kern/anwendungsfaelle.js";
+import { AbhaengigkeitFehlt, BundleDateiFehler, BundleMehrdeutig, BundleMitgliederFehlen, BundleNamenskonflikte, BundleNichtInstalliert, BundleUnbekannt, EinschraenkungOhneZeiger, HarnessNichtVorhanden, HarnessTypUnbekannt, KeinPassenderRef, LinkAnlegenFehlgeschlagen, McpAbweichenderEintrag, McpEbeneNichtUnterstuetzt, McpFaehigkeitFehlt, McpKatalogFehler, McpNichtInGeteilterDatei, McpNurGeteilterFundort, McpUebernahmeNichtMoeglich, McpUebernahmeUnvollstaendig, McpUnbekannt, NameBelegt, OrtNichtUnterstuetzt, PluginMehrdeutig, PluginUnbekannt, QuelleAufraeumenLokaleAenderungen, QuelleNameBelegt, QuelleUnbekannt, SkillMehrdeutig, SkillOrdnerBereitsVerwaltet, SkillOrdnerFaehigkeitFehlt, SkillOrdnerNichtVerwaltet, SkillOrdnerUngueltig, SkillUnbekannt, ZeigerMehrdeutig, ZeigerSchreibenGesperrt, pluginSchluessel, quelleName, quelleSchluessel, } from "../kern/modell.js";
 import { Agents } from "../adapter/agents.js";
 import { ClaudeCode } from "../adapter/claude-code.js";
 import { Hermes } from "../adapter/hermes.js";
@@ -13,6 +13,7 @@ import { ComposerZeiger } from "../adapter/composer.js";
 import { DateisystemZiele } from "../adapter/dateisystem.js";
 import { GitQuellen } from "../adapter/git.js";
 import { DateiMcpKatalog } from "../adapter/mcp-katalog.js";
+import { paketVersion } from "../adapter/paket-version.js";
 import { quelleAlsText, quelleAusText } from "../adapter/quelle-text.js";
 import { TerminalRueckfrage } from "../adapter/terminal.js";
 import { ProzessUmgebung } from "../adapter/umgebung.js";
@@ -59,6 +60,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: [] },
     mcp: { werte: ['harness', 'ort'], flaggen: [] },
     sync: { werte: [], flaggen: [] },
     update: { werte: [], flaggen: [] },
@@ -87,6 +89,13 @@ const UNTERKOMMANDOS = {
         remove: { woerter: 2, schalter: ['harness', 'ort', 'composer', 'local', 'lokal'] },
         list: { woerter: 1, schalter: [] },
     },
+    bundle: {
+        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'] },
+        list: { woerter: 1, schalter: [] },
+    },
     mcp: {
         add: { woerter: 2, schalter: ['harness', 'ort'] },
         remove: { woerter: 2, schalter: ['harness', 'ort'] },
@@ -179,6 +188,11 @@ const UEBERNAHME_GRUND = {
 export async function ausfuehren(argv, umgebung, optionen = {}) {
     const { anwendungsfaelle, ports } = bauen(umgebung, optionen);
     const kommando = argv[0];
+    // Version vor allem anderen (E72): nur die Nummer, damit ein Skript sie ohne Nacharbeit liest.
+    if (kommando === '--version') {
+        console.log(paketVersion());
+        return 0;
+    }
     // Hilfe zuerst: --help ist überall eine Flagge, damit kein Kommando sie als Wert liest.
     if (kommando === undefined) {
         console.log(HILFE);
@@ -377,6 +391,9 @@ 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.`);
             if (ergebnis.hinweis !== undefined)
                 console.log(ergebnis.hinweis);
             return 0;
@@ -490,6 +507,89 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
                 console.log(`  ${zeile}`);
         return 0;
     }
+    if (kommando === 'bundle') {
+        const schalter = schalterLesen(argv.slice(1), 'bundle');
+        unterkommandoPruefen('bundle', schalter);
+        const { rest, werte } = schalter;
+        const unterkommando = rest[0];
+        if (unterkommando === 'list') {
+            const katalog = await anwendungsfaelle.bundleKatalog();
+            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.');
+            for (const eintrag of katalog) {
+                if (eintrag.fehler !== undefined) {
+                    console.log(`Quelle ${quelleName(eintrag.quelle)}  (${quelleAlsText(eintrag.quelle)})  nicht lesbar: ${eintrag.fehler}`);
+                    continue;
+                }
+                if (eintrag.bundles.length === 0 && eintrag.kaputte.length === 0)
+                    continue;
+                console.log(`Quelle ${quelleName(eintrag.quelle)}  (${quelleAlsText(eintrag.quelle)})`);
+                for (const bundle of eintrag.bundles) {
+                    console.log(`  ${bundle.name}  ${kappen(bundle.beschreibung)}`);
+                    for (const mitglied of bundle.mitglieder)
+                        console.log(`    ${mitglied.pfad}  aus ${quelleAlsText(mitglied.quelle)}`);
+                }
+                // Eine kaputte Definition verdeckt die übrigen nicht, sie wird eigens genannt (E69).
+                for (const kaputt of eintrag.kaputte)
+                    console.log(`  Fehler  ${kaputt.datei}: ${kaputt.fehler}`);
+            }
+            return 0;
+        }
+        if (unterkommando !== 'add' && unterkommando !== 'remove' && unterkommando !== 'sync')
+            throw new Error(`${unterkommando === undefined ? 'bundle braucht ein Unterkommando' : `Unbekanntes Unterkommando „${unterkommando}" für bundle`}: bundle add <name>, bundle remove <name>, bundle sync [name] oder bundle list. hmgr help bundle zeigt Beispiele.`);
+        const name = rest[1];
+        if (name === undefined && unterkommando !== 'sync')
+            throw new Error(`bundle ${unterkommando} braucht einen Bundle-Namen. hmgr bundle list zeigt die Bundles der bekannten Quellen.`);
+        const ziel = { harness: werte.get('harness') ?? 'claude-code', ort: ortLesen(werte.get('ort')) };
+        if (ziel.ort.art === 'arbeitsverzeichnis') {
+            // Wie bei link: Verzeichnis merken und binden, damit status es wiederfindet (E21).
+            const composer = werte.get('composer');
+            if (composer === undefined)
+                await anwendungsfaelle.arbeitsverzeichnisHinzufuegen(ziel.ort.pfad);
+            else
+                await anwendungsfaelle.arbeitsverzeichnisHinzufuegen(ziel.ort.pfad, composer);
+        }
+        if (unterkommando === 'add') {
+            const quelle = werte.get('quelle');
+            const ergebnis = await anwendungsfaelle.bundleInstallieren({
+                bundle: name,
+                ziel,
+                ...(quelle === undefined ? {} : { quelle }),
+            });
+            console.log(`Bundle ${ergebnis.bundle.name} in ${ziel.harness} ${beschreibeOrt(ziel.ort)} installiert (${quelleAlsText(ergebnis.bundle.quelle)}).`);
+            for (const neu of ergebnis.neueQuellen)
+                console.log(`  neue Quelle   ${quelleAlsText(neu)} als „${quelleName(neu)}"`);
+            if (ergebnis.gelegt.length > 0)
+                console.log(`  gelegt        ${ergebnis.gelegt.join(', ')}`);
+            // Übernommen (F67): schon vorhandene Links derselben Quelle gehören jetzt zum Bundle.
+            if (ergebnis.uebernommen.length > 0)
+                console.log(`  übernommen    ${ergebnis.uebernommen.join(', ')}`);
+            if (ergebnis.hinweis !== undefined)
+                for (const zeile of ergebnis.hinweis.split('\n'))
+                    console.log(`  ${zeile}`);
+            return 0;
+        }
+        if (unterkommando === 'remove') {
+            const ergebnis = await anwendungsfaelle.bundleEntfernen({ bundle: name, ziel });
+            console.log(`Bundle ${ergebnis.bundle} aus ${ziel.harness} ${beschreibeOrt(ziel.ort)} entfernt.`);
+            console.log(ergebnis.entfernt.length === 0
+                ? '  Kein Link mehr da, nur der Bundle-Verweis ist weg.'
+                : `  entfernt      ${ergebnis.entfernt.join(', ')}`);
+            return 0;
+        }
+        // sync: ohne Ziel-Schalter der ganze Bestand, mit --ort/--harness nur dieses Ziel.
+        const nurZiel = werte.has('harness') || werte.has('ort');
+        const eintraege = await anwendungsfaelle.bundleAbgleich({
+            ...(name === undefined ? {} : { bundle: name }),
+            ...(nurZiel ? { ziel } : {}),
+        });
+        if (eintraege.length === 0)
+            console.log('Kein Bundle installiert, nichts abzugleichen.');
+        for (const zeile of bundleBericht(eintraege))
+            console.log(zeile);
+        return 0;
+    }
     if (kommando === 'mcp') {
         const schalter = schalterLesen(argv.slice(1), 'mcp');
         unterkommandoPruefen('mcp', schalter);
@@ -568,13 +668,18 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
     }
     if (kommando === 'update') {
         restPruefen(schalterLesen(argv.slice(1), 'update').rest, 0, 'update');
-        const { checkouts: liste, pluginHarnesses, aufraeumen } = await anwendungsfaelle.aktualisieren();
+        const { checkouts: liste, pluginHarnesses, bundles, aufraeumen } = await anwendungsfaelle.aktualisieren();
         if (liste.length === 0)
             console.log('Keine Checkouts.');
-        for (const { checkout, aktualisierung } of liste) {
+        for (const { checkout, aktualisierung, geaenderteSkills } of liste) {
             const kopf = `${quelleAlsText(checkout.quelle)} @ ${checkout.ref}`;
-            if (aktualisierung.ergebnis === 'aktualisiert')
+            if (aktualisierung.ergebnis === 'aktualisiert') {
                 console.log(`  aktualisiert    ${kopf}  ${aktualisierung.von.slice(0, 8)} -> ${aktualisierung.nach.slice(0, 8)}`);
+                // Auf Skill-Ebene berichten (E70): sonst steht da nur, dass die Quelle neue Commits hat.
+                // Ohne Treffer bleibt die Zeile weg — der Commit hat dann nichts in einem Skill geändert.
+                if (geaenderteSkills.length > 0)
+                    console.log(`                  ${zahlwort(geaenderteSkills.length, 'Skill', 'Skills')} geändert: ${geaenderteSkills.join(', ')}`);
+            }
             else if (aktualisierung.ergebnis === 'unveraendert')
                 console.log(`  unverändert     ${kopf}`);
             else if (aktualisierung.ergebnis === 'uebersprungen')
@@ -584,6 +689,9 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
         }
         for (const name of pluginHarnesses)
             console.log(`  Plugins         ${name} aktualisiert (E14)`);
+        // Bundles im selben Lauf (E69, F64=O1): eine geänderte Definition wird hier nachgezogen.
+        for (const zeile of bundleBericht(bundles))
+            console.log(zeile);
         // Zum Schluss die verwaisten Checkouts: was gelöscht wurde und was liegen bleibt.
         for (const verwaist of aufraeumen.verwaiste) {
             const kopf = `${quelleAlsText(verwaist.checkout.quelle)} @ ${verwaist.checkout.ref}`;
@@ -618,6 +726,9 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
                     console.log(`  ${eintrag.link.name}  ${spanne}${quelleAlsText(eintrag.link.checkout.quelle)} @ ${eintrag.link.checkout.ref} (${eintrag.link.skill.pfad})${beschreibeGrund(zielZustand.gruende.get(eintrag.link.name))}`);
                 }
             }
+            // 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(', ')}`);
             if (zielZustand.plugins !== undefined)
                 console.log(`  Plugins: ${zielZustand.plugins.length === 0 ? 'keine' : zielZustand.plugins.join(', ')}`);
         }
@@ -738,6 +849,31 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
     }
     throw new Error(`Unbekanntes Kommando „${kommando}". hmgr --help zeigt alle Kommandos.`);
 }
+/**
+ * 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
+ * genau das — der Zusatz sagt, dass das Bundle im Ziel auf dem alten Stand bleibt.
+ */
+function bundleBericht(eintraege) {
+    const zeilen = [];
+    for (const eintrag of eintraege) {
+        const kopf = `Bundle ${eintrag.bundle}  ${eintrag.ziel.harness} ${beschreibeOrt(eintrag.ziel.ort)}`;
+        if (eintrag.ergebnis === 'fehlgeschlagen') {
+            zeilen.push(`  fehlgeschlagen  ${kopf}  bleibt auf dem alten Stand`);
+            for (const zeile of (eintrag.fehler ?? '').split('\n'))
+                zeilen.push(`    ${zeile}`);
+            continue;
+        }
+        zeilen.push(`  ${eintrag.ergebnis === 'aktualisiert' ? 'aktualisiert   ' : 'unverändert    '} ${kopf}`);
+        for (const neu of eintrag.neueQuellen)
+            zeilen.push(`    neue Quelle   ${quelleAlsText(neu)}`);
+        if (eintrag.gelegt.length > 0)
+            zeilen.push(`    gelegt        ${eintrag.gelegt.join(', ')}`);
+        if (eintrag.entfernt.length > 0)
+            zeilen.push(`    entfernt      ${eintrag.entfernt.join(', ')}`);
+    }
+    return zeilen;
+}
 /** Grund eines Links als Suffix (E37). „manuell" bleibt stumm, damit die Ausgabe ruhig bleibt. */
 function beschreibeGrund(grund) {
     if (grund === undefined || grund.art === 'manuell')
@@ -774,6 +910,12 @@ function istModellFehler(fehler) {
         fehler instanceof PluginMehrdeutig ||
         fehler instanceof PluginUnbekannt ||
         fehler instanceof AbhaengigkeitFehlt ||
+        fehler instanceof BundleUnbekannt ||
+        fehler instanceof BundleMehrdeutig ||
+        fehler instanceof BundleMitgliederFehlen ||
+        fehler instanceof BundleNamenskonflikte ||
+        fehler instanceof BundleNichtInstalliert ||
+        fehler instanceof BundleDateiFehler ||
         fehler instanceof QuelleUnbekannt ||
         fehler instanceof QuelleNameBelegt ||
         fehler instanceof QuelleAufraeumenLokaleAenderungen ||
@@ -808,6 +950,18 @@ function naechsterSchritt(fehler) {
         return 'hmgr plugin list zeigt die Plugins der bekannten Quellen. Fehlt der Marketplace, erst hmgr source add <url>.';
     if (fehler instanceof AbhaengigkeitFehlt)
         return 'Die Abhängigkeit steht in keinem Plugin desselben Marketplace, das kann nur die Quelle beheben.';
+    if (fehler instanceof BundleUnbekannt)
+        return 'hmgr bundle list zeigt die Bundles der bekannten Quellen. Fehlt die Quelle, erst hmgr source add <url|pfad>.';
+    if (fehler instanceof BundleMehrdeutig)
+        return 'Quelle eingrenzen: --quelle <teilstring der URL oder des Pfads>. hmgr bundle list zeigt, wo welches Bundle steht.';
+    if (fehler instanceof BundleMitgliederFehlen)
+        return 'Das Bundle ist nur ganz oder gar nicht zu haben. Wer nur einen Teil braucht, verlinkt die erreichbaren Skills einzeln mit hmgr link.';
+    if (fehler instanceof BundleNamenskonflikte)
+        return 'Die genannten Namen erst freimachen (hmgr unlink <skill> bzw. hmgr adopt <name>), dann bundle add erneut.';
+    if (fehler instanceof BundleNichtInstalliert)
+        return 'hmgr status zeigt je Ziel, welche Bundles dort installiert sind.';
+    if (fehler instanceof BundleDateiFehler)
+        return 'Die Definition liegt in der Quelle und wird dort korrigiert, hmgr schreibt sie nie. hmgr help bundle zeigt das Format.';
     if (fehler instanceof KeinPassenderRef)
         return 'Die Tags der Quelle sind frisch geholt, keiner passt. Sonst einen vorhandenen Tag- oder Branchnamen als --version nennen.';
     if (fehler instanceof HarnessNichtVorhanden)

package/dist/gui/main.js

@@ -9,6 +9,7 @@ import { stat } from 'node:fs/promises';
 import { fileURLToPath } from 'node:url';
 import { bauen, umgebungLesen } from "../cli/main.js";
 import { quelleAlsText, quelleAusText } from "../adapter/quelle-text.js";
+import { paketVersion } from "../adapter/paket-version.js";
 import { quelleName, quelleSchluessel } from "../kern/modell.js";
 import { kannProfile } from "../ports/harness.js";
 import { iconFuerQuelle } from "./icons.js";
@@ -136,6 +137,14 @@ function zielZustandSerialisieren(z) {
         gruende: Object.fromEntries(z.gruende),
         ignoriert: z.ignoriert,
         uebernahme: Object.fromEntries(z.uebernahme),
+        // Bundles des Ziels (E69): Adresse und Anzeigename der Quelle kommen mit, damit der Renderer
+        // die Gruppe beschriften kann, ohne die Quelle selbst nachzuschlagen.
+        bundles: z.bundles.map((b) => ({
+            name: b.name,
+            skills: b.skills,
+            quelleText: quelleAlsText(b.quelle),
+            quelleName: quelleName(b.quelle),
+        })),
         istRegistriert: z.istRegistriert,
         kannSkillOrdner: z.kannSkillOrdner,
         ...(z.plugins === undefined ? {} : { plugins: z.plugins }),
@@ -181,6 +190,7 @@ function registriereIpc() {
                     ...(skill.modell === undefined ? {} : { modell: skill.modell }),
                     ...(skill.eigenerKontext === undefined ? {} : { eigenerKontext: skill.eigenerKontext }),
                     ...(skill.argumentHinweis === undefined ? {} : { argumentHinweis: skill.argumentHinweis }),
+                    ...(skill.geaendert === undefined ? {} : { geaendert: skill.geaendert }),
                     quelleText: quelleAlsText(eintrag.quelle),
                     quelleName: quelleName(eintrag.quelle),
                     quelleSchluessel: quelleSchluessel(eintrag.quelle),
@@ -189,6 +199,45 @@ 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.
+    ipcMain.handle('hmgr:bundles', async () => auffangen(async () => {
+        const bundles = [];
+        const kaputte = [];
+        for (const eintrag of await anwendungsfaelle.bundleKatalog()) {
+            for (const bundle of eintrag.bundles)
+                bundles.push({
+                    name: bundle.name,
+                    beschreibung: bundle.beschreibung,
+                    mitglieder: bundle.mitglieder.length,
+                    // 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),
+                    quelleName: quelleName(bundle.quelle),
+                });
+            for (const kaputt of eintrag.kaputte)
+                kaputte.push({ quelleName: quelleName(eintrag.quelle), datei: kaputt.datei, fehler: kaputt.fehler });
+        }
+        return { bundles, kaputte };
+    }));
+    // Installieren und Entfernen wirken auf das Bundle als Ganzes (E69). Der Zeiger ist nicht im
+    // Spiel, die Zugehörigkeit steht im Zustand — anders als bei linkLegen braucht es kein `lokal`.
+    ipcMain.handle('hmgr:bundleInstallieren', async (_event, args) => auffangen(async () => {
+        const ergebnis = await anwendungsfaelle.bundleInstallieren({
+            bundle: args.bundle,
+            ziel: zielAusIpc(args.harness, args.ort),
+            ...(args.quelle === undefined ? {} : { quelle: args.quelle }),
+        });
+        return {
+            name: ergebnis.bundle.name,
+            gelegt: ergebnis.gelegt,
+            uebernommen: ergebnis.uebernommen,
+            neueQuellen: ergebnis.neueQuellen.map((q) => quelleName(q)),
+            ...(ergebnis.hinweis === undefined ? {} : { hinweis: ergebnis.hinweis }),
+        };
+    }));
+    ipcMain.handle('hmgr:bundleEntfernen', async (_event, args) => auffangen(async () => anwendungsfaelle.bundleEntfernen({ bundle: args.bundle, ziel: zielAusIpc(args.harness, args.ort) })));
     // 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,
@@ -386,6 +435,11 @@ function fensterOeffnen() {
         minWidth: 860,
         minHeight: 560,
         backgroundColor: '#E3E7E0', // --platte, verhindert einen weißen Blitz beim Start
+        // E72: der Fenstertitel nennt die Version, damit im Feld erkennbar ist, welcher Stand läuft.
+        // Nicht `app.getVersion()`: das liefert nur im gepackten Bundle die Paketversion, beim Start
+        // über `electron dist/gui/main.js` (npm run gui, Smoke-Test) dagegen die Electron-Version —
+        // dort liegt neben dem Hauptskript keine package.json (gemessen: 44.0.0 statt 0.0.6).
+        title: `hmgr ${paketVersion()}`,
         // Im Smoke-Test bleibt das Fenster unsichtbar: der Renderer lädt trotzdem vollständig, der
         // DOM-Auszug kommt per executeJavaScript. So klaut ein automatisierter Lauf niemandem den
         // Eingabefokus und öffnet kein sichtbares Fenster.
@@ -400,6 +454,9 @@ function fensterOeffnen() {
     hauptfenster.on('closed', () => {
         hauptfenster = null;
     });
+    // Der <title> der index.html setzt den Fenstertitel beim Laden sonst zurück und überschriebe die
+    // Option oben (E72). Der DOM-Titel bleibt dabei, wie er ist, nur das Fenster folgt ihm nicht mehr.
+    hauptfenster.on('page-title-updated', (ereignis) => ereignis.preventDefault());
     // Renderer-Konsole im Main-Log, für Fehlersuche und den Smoke-Test.
     hauptfenster.webContents.on('console-message', (event) => {
         console.log(`[renderer] ${event.message}`);
@@ -507,6 +564,9 @@ function fensterOeffnen() {
               // Katalog (E40 R3, R5): Beschreibung aus dem Fixture muss in der Skill-Zeile stehen.
               document.querySelector('[data-ansicht="katalog"]')?.click();
               var katalogBeschreibung = document.querySelector('#katalog .zeile .beschreibung')?.textContent ?? null;
+              // E70/F70=O1: die Herkunftszeile trägt hinter dem Ref das Änderungsdatum des Skills.
+              var katalogHerkunft = document.querySelector('#katalog .zeile .herkunft')?.textContent
+                ?.replace(/\\s+/g, ' ').trim() ?? null;
               // Besonderheiten aus dem Frontmatter (E55): Marken an der Zeile, Details erst nach
               // einem Klick auf den Aufklapp-Knopf.
               var katalogMarken = document.querySelector('#katalog .zeile .marken')?.textContent
@@ -524,12 +584,34 @@ function fensterOeffnen() {
               var dskKnopf = Array.from(document.querySelectorAll('button'))
                 .find((b) => b.textContent === 'Skills hinzufügen');
               var dskMarken = null;
+              // Bundle-Sektion im selben Dialog (E69, F68): sie steht dort, wo die Entscheidung
+              // fällt, was ins Ziel kommt, und zeigt je Bundle Beschreibung und Herkunft.
+              var dskBundleBoxSichtbar = false;
+              var dskBundleText = null;
               if (dskKnopf) {
                 dskKnopf.click();
                 dskMarken = document.querySelector('#dsk-liste .wahlzeile .marken')?.textContent
                   ?.replace(/\\s+/g, ' ').trim() ?? null;
+                dskBundleBoxSichtbar = document.getElementById('dsk-bundlebox')?.hidden === false;
+                dskBundleText = document.querySelector('#dsk-bundles .wahlzeile')?.textContent
+                  ?.replace(/\\s+/g, ' ').trim() ?? null;
                 document.getElementById('d-skills')?.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
+                ?.replace(/\\s+/g, ' ').trim() ?? null;
+              var bundleGruppeZeilen = Array.from(document.querySelectorAll('#zielliste .bundlegruppe .linkliste .name'))
+                .map((n) => n.textContent.trim()).join(',');
+              // Entfernen an der Einzelzeile innerhalb der Gruppe sagt, dass das Bundle zerbricht.
+              var bundleZerbrichtText = null;
+              try {
+                document.querySelector('#zielliste .bundlegruppe .linkliste .knopf')?.click();
+                bundleZerbrichtText = document.getElementById('dx-text')?.textContent ?? null;
+                document.querySelector('#d-entfernen button[value="nein"]')?.click();
+              } catch (fehler) {
+                bundleZerbrichtText = String(fehler);
+              }
               // MCP-Ansicht (E61-Folgerunde, F46: abgespeckt zum reinen Katalog): Navigationsreihenfolge
               // Ziele, MCP, Plugins, Skills, Karten mit Name/Beschreibung/Homepage-Link, F39-Warnzeile,
               // Einhängen-Dialog öffnen/abbrechen ohne IPC-Schreibaktion. Orte-Liste und Fremdkasten
@@ -640,6 +722,14 @@ function fensterOeffnen() {
                 ?.replace(/\\s+/g, ' ').trim() ?? null;
               var kundeXMcpZeilenKnopfZahl = kundeXKarte?.querySelectorAll('.mcpkartezeilen button').length ?? 0;
               var kundeXMcpKnopfVorhanden = mcpHinzuKnopfAn(kundeXKarte) !== undefined;
+              // Kartenkopf-Zahl (E71): der Kopf zählt Skills, gebündelt wie der Körper zeilt. An der
+              // Verzeichnis-Karte kunde-x hängen dieselben zwei Skills an zwei Harnesses, eine Summe
+              // über die Abschnitte ergäbe hier 4.
+              var kopfZahlVon = function (karte) {
+                return karte?.querySelector('.zielkopf .zahl')?.textContent?.trim() ?? null;
+              };
+              var kundeXKopfZahl = kopfZahlVon(kundeXKarte);
+              var hermesKopfZahl = kopfZahlVon(hermesKarte);
               var agentsKarte = karteMitKopftext('Agents · Home');
               // Ohne diese Zusicherung wären die beiden Abwesenheits-Prüfungen darunter leer erfüllt,
               // sobald die Karte selbst aus der Liste fiele: „kein Abschnitt" hieße dann nur „keine Karte".
@@ -678,12 +768,18 @@ function fensterOeffnen() {
                 zielManuellVorhanden,
                 zahnradVorhanden,
                 katalogBeschreibung,
+                katalogHerkunft,
                 katalogMarken,
                 katalogDetailsZu,
                 katalogAufgeklappt,
                 katalogDetails,
                 katalogMarkenWarnend,
                 dskMarken,
+                dskBundleBoxSichtbar,
+                dskBundleText,
+                bundleGruppeText,
+                bundleGruppeZeilen,
+                bundleZerbrichtText,
                 interGeladen: document.fonts.check('400 16px Inter'),
                 monoGeladen: document.fonts.check('500 16px "JetBrains Mono"'),
                 quelleneuVorhanden,
@@ -733,6 +829,8 @@ function fensterOeffnen() {
                 kundeXMcpText,
                 kundeXMcpZeilenKnopfZahl,
                 kundeXMcpKnopfVorhanden,
+                kundeXKopfZahl,
+                hermesKopfZahl,
                 agentsKarteVorhanden,
                 agentsMcpAbschnittVorhanden,
                 agentsMcpKnopfVorhanden,
@@ -743,6 +841,9 @@ function fensterOeffnen() {
               });
             })()`)
                     .then((auszug) => console.log(`[smoke] DOM-Auszug: ${auszug}`))
+                    // E72: der Fenstertitel steht nicht im DOM (dort steht weiter der <title> der
+                    // index.html), er lässt sich nur hier im Main-Prozess ablesen.
+                    .then(() => console.log(`[smoke] Fenster: ${JSON.stringify({ fenstertitel: fenster.getTitle() })}`))
                     .finally(() => app.quit());
             }, 3000);
         });

package/dist/gui/preload.cjs

@@ -11,6 +11,10 @@ contextBridge.exposeInMainWorld('hmgr', {
     marketplaces: () => ipcRenderer.invoke('hmgr:marketplaces'),
     skills: () => ipcRenderer.invoke('hmgr:skills'),
     quellen: () => ipcRenderer.invoke('hmgr:quellen'),
+    /** Bundles aller bekannten Quellen (E69), entdeckt beim Quellen-Scan: kein eigener Katalog. */
+    bundles: () => ipcRenderer.invoke('hmgr:bundles'),
+    bundleInstallieren: (args) => ipcRenderer.invoke('hmgr:bundleInstallieren', args),
+    bundleEntfernen: (args) => ipcRenderer.invoke('hmgr:bundleEntfernen', 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/index.html

@@ -216,7 +216,18 @@
         <svg viewBox="0 0 16 16" stroke-width="1.6" aria-hidden="true"><circle cx="7" cy="7" r="4.5"/><path d="M10.5 10.5 14.5 14.5"/></svg>
         <input type="search" id="dsk-suche" placeholder="Skill suchen" aria-label="Skills durchsuchen">
       </div>
-      <div class="wahl" id="dsk-liste"></div>
+      <!-- Bundle-Sektion (E69, F68): kein eigener Navigationspunkt, Bundles stehen hier, wo die
+           Entscheidung fällt, was ins Ziel kommt. Leer bleibt der Kasten weg. -->
+      <div class="dskgruppe" id="dsk-bundlebox" hidden>
+        <span class="etikett">Bundles</span>
+        <p class="ohne dskgruppentext">Ein Bundle bringt eine ganze Zusammenstellung auf einmal, auch über Quellen hinweg. Fehlende Quellen legt hmgr dabei an.</p>
+        <div class="wahl" id="dsk-bundles"></div>
+        <p class="ohne dskgruppenfehler" id="dsk-bundlefehler" hidden></p>
+      </div>
+      <div class="dskgruppe">
+        <span class="etikett" id="dsk-skilletikett">Skills</span>
+        <div class="wahl" id="dsk-liste"></div>
+      </div>
     </div>
     <div class="dfuss">
       <span class="links mono" id="dsk-bilanz">0 ausgewählt</span>