hmgr 0.0.5 → 0.0.7

package/dist/cli/hilfe.js

@@ -22,6 +22,14 @@ hmgr <kommando> [schalter]
   plugin add <name>         Plugin in ein Ziel legen (installieren oder Skills verlinken)
   plugin remove <name>      Plugin aus einem Ziel entfernen
   plugin list               Plugins der Marketplaces aller Quellen
+  bundle add <name>         Bundle als Ganzes in ein Ziel installieren
+  bundle remove <name>      Bundle als Ganzes aus einem Ziel entfernen
+  bundle sync [name]        Installierte Bundles gegen ihre Definition ziehen
+  bundle list               Bundles der bekannten Quellen
+  mcp add <name>            MCP-Server aus dem Katalog in ein Ziel einhängen
+  mcp remove <name>         MCP-Server aus einem Ziel aushängen
+  mcp migrate <name>        MCP-Server aus der geteilten .mcp.json in den privaten Scope übernehmen
+  mcp list                  Katalog-Einträge zeigen, mit wo sie eingehängt sind
   sync [pfad]               Ziel auf den Stand seines Zeigers bringen
   update                    Alle Checkouts aktualisieren
   status                    Ist-Zustand der Ziele
@@ -29,6 +37,7 @@ hmgr <kommando> [schalter]
   harness enable <name>     Harness-Typ aktivieren, hmgr richtet ihn künftig ein
   harness disable <name>    Harness-Typ deaktivieren, mit Angebot zum Säubern
   harness skills-dir <name> Verwalteten Skill-Ordner zeigen, festlegen oder entfernen
+  --version                 Versionsnummer von hmgr ausgeben
 
 hmgr help <kommando> zeigt Schalter, Beispiele und Zusammenhänge.`;
 const SOURCE = `hmgr source add <url|pfad> [--name <name>]
@@ -226,6 +235,180 @@ Häufige Fälle:
   kann nur die Quelle beheben.
 
 Siehe auch: hmgr help source, hmgr help sync`;
+const BUNDLE = `hmgr bundle add <name> [schalter]
+hmgr bundle remove <name> [schalter]
+hmgr bundle sync [name] [schalter]
+hmgr bundle list
+
+Ein Bundle ist eine benannte Zusammenstellung von Skills über Quellen hinweg: was für ein Vorhaben
+zusammengehört, liegt selten in einem Repo. Anders als ein Plugin (das lebt in einem Marketplace und
+löst Abhängigkeiten nur dort auf) darf ein Bundle Skills aus beliebig vielen Quellen nennen.
+
+Definiert wird es von Hand, als YAML-Datei in einer Quelle, Konvention bundles/<name>.yaml. hmgr
+liest und validiert sie, schreibt sie nie — über die Quelle kommt sie versioniert auf alle
+Maschinen. Es gibt keinen eigenen Katalog und keinen Pflegebefehl: bundle list zeigt, was beim
+Quellen-Scan gefunden wurde.
+
+Format der Datei:
+
+  name          optional, sonst gilt der Dateiname ohne Endung
+  description   Pflicht, kurzer Text
+  skills        Pflicht, nicht leere Liste; je Eintrag source (URL oder Pfad der Quelle)
+                und path (Pfad des Skill-Ordners in dieser Quelle)
+
+Beispiel bundles/wordpress.yaml:
+
+  name: wordpress
+  description: Alles für die WordPress-Arbeit
+  skills:
+    - source: git@gitea.example.com:tim/skills.git
+      path: skills/wp-core
+    - source: https://github.com/taquiri/skills
+      path: skills/tq-mailform
+
+Ein Ref je Mitglied kennt die Definition nicht: der Link folgt dem Ref, mit dem die Quelle
+eingerichtet ist. Angesprochen wird der Skill über seinen Pfad, nicht über seinen Namen — der Name
+steht im Frontmatter und wird erst beim Lesen der Quelle bekannt.
+
+Je Ziel ist das Bundle eine Einheit: add legt alle seine Links, remove nimmt alle wieder weg, sync
+zieht Änderungen an der Definition nach. Nennt die Definition eine Quelle, die hmgr noch nicht
+kennt, legt add sie an und sagt, welche neu sind. Lässt sich auch nur ein Mitglied nicht auflösen
+oder liegt am Ziel ein Namenskonflikt, bricht add ab, bevor irgendetwas verlinkt oder eine Quelle
+angelegt ist — ein halbes Bundle wäre stilles Fehlen von Skills. Wer nur einen Teil braucht,
+verlinkt die erreichbaren Skills einzeln mit hmgr link.
+
+Liegt am Ziel schon derselbe Skill aus derselben Quelle als hmgr-Link, wird er als Mitglied
+ü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.
+
+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
+Aktualisieren an, ohne dass man von der Änderung wissen müsste. bundle sync ist der gezielte Weg
+daneben, wenn nur ein Bundle oder nur ein Ziel gemeint ist; ohne Namen und ohne Ziel-Schalter geht
+es denselben Bestand durch wie update. Was sich nicht vollständig nachziehen lässt, bleibt in
+seinem Ziel auf dem alten Stand und wird als fehlgeschlagen gemeldet.
+
+Der Zeiger bleibt außen vor: die Zugehörigkeit der Links führt hmgr in seinem Zustand, nicht in der
+composer.json. --local gibt es deshalb nicht, und die Sperre aus E57 trifft bundle nie.
+
+Schalter (add, remove und sync):
+  --harness <name>    claude-code, hermes oder agents, Standard claude-code
+  --ort <ort>         home, dir:<pfad> oder profil:<name>, Standard home. profil kennt nur hermes
+  --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
+
+Beispiele:
+  hmgr bundle list
+  hmgr bundle add wordpress --ort dir:.
+  hmgr bundle sync
+  hmgr bundle remove wordpress --ort dir:.
+
+Häufige Fälle:
+  „steht in keiner Quelle": hmgr bundle list zeigt die bekannten Namen, sonst erst hmgr source add.
+  „liegt in mehreren Quellen": mit --quelle <teilstring> entscheiden.
+  „ist auf dieser Maschine nicht vollständig herstellbar": die Meldung nennt je Mitglied den Grund,
+  meist eine Quelle ohne Zugriff oder ein Pfad, an dem kein Skill (mehr) liegt.
+  „lässt sich in … nicht anlegen": die Meldung listet alle Namen, die am Ziel schon belegt sind.
+  „kein Bundle … installiert": hmgr status zeigt je Ziel seine Bundles.
+
+Siehe auch: hmgr help link, hmgr help plugin, hmgr help status`;
+const MCP = `hmgr mcp add <name> [schalter]
+hmgr mcp remove <name> [schalter]
+hmgr mcp migrate <name> [schalter]
+hmgr mcp list
+
+Ein MCP-Server ist ein Eintrag im persönlichen Katalog ~/.hmgr/mcp.yaml, nicht in einer Quelle: kein
+Download, keine Installation, kein Update. hmgr liest den Katalog nur, er wird von Hand oder von
+einem LLM gepflegt, das den MCP ohnehin gerade einrichtet. mcp add hängt einen Katalog-Eintrag in
+ein Ziel ein (Projekt oder global), mcp remove hängt ihn wieder aus, mcp list zeigt den Katalog mit
+je Eintrag, wo er eingehängt ist, dazu Einträge, die in Harness-Konfigurationen liegen, aber nicht
+im Katalog stehen (nur genannt, hmgr fasst sie nicht an). mcp list sieht dabei in den Homes und
+Profilen der Harnesses nach und in den Arbeitsverzeichnissen, die hmgr kennt (hmgr dir add); ein
+MCP in einem Verzeichnis, das hmgr nicht kennt, taucht dort nicht auf.
+
+Format von ~/.hmgr/mcp.yaml: ein Objekt, Schlüssel ist der MCP-Name. Je Eintrag:
+
+  beschreibung   Pflicht, kurzer Text
+  homepage       optional, URL
+  notizen        optional, mehrzeilig
+  konfig         Pflicht: entweder command (Pflicht), optional args und env,
+                 oder url (Pflicht), optional headers
+
+Andere Schlüssel im konfig-Block sind ein Fehler, mit Eintrag und Feld in der Meldung. Secrets
+stehen als \${VAR}- oder \${env:VAR}-Verweise im Block, nie im Klartext; aufgelöst werden sie vom
+Harness gegen dessen Umgebung, hmgr prüft beim Einhängen nur, ob die Variablen gesetzt sind, und
+warnt sonst. Fehlt die Datei, ist der Katalog leer, kein Fehler; kaputtes YAML ist ein Fehler mit
+dem Dateipfad.
+
+Beispiel:
+
+  teamwork:
+    beschreibung: Teamwork.com Projektmanagement
+    homepage: https://teamwork.com
+    notizen: |
+      Erfordert TEAMWORK_API_KEY, siehe Teamwork-Profil.
+    konfig:
+      command: npx
+      args: ["-y", "@teamwork/mcp-server"]
+      env:
+        TEAMWORK_API_KEY: \${TEAMWORK_API_KEY}
+
+  context7:
+    beschreibung: Context7 Doku-Suche
+    konfig:
+      url: https://mcp.context7.com/mcp
+      headers:
+        Authorization: Bearer \${env:CONTEXT7_TOKEN}
+
+Die Fähigkeit hängt am Harness-Adapter, nicht am Namen (E16): claude-code kennt Projekt (Scope
+local, nie die geteilte .mcp.json der Projektwurzel, das bleibt Team-Sache wie beim Zeiger, E57) und
+global (Scope user). Hermes kennt nur global, mcp_servers in seiner config.yaml (Home oder Profil
+mit --ort profil:<name>); ein Projekt-Ziel ist bei Hermes ein Fehler, es kennt keine Projektebene für
+MCPs. agents kennt MCP-Server gar nicht.
+
+mcp migrate ist der einzige Weg, auf dem hmgr die geteilte .mcp.json anfasst (E64): der Eintrag
+wandert 1:1 aus der Datei in deinen privaten Scope am selben Ort und wird dort gelöscht. Auch ein
+Eintrag, der nicht im Katalog steht, lässt sich so übernehmen — der Konfigblock kommt aus der Datei,
+nicht aus dem Katalog. Ist die Datei mit dem Team geteilt, verlieren die anderen den Server, sobald
+die Änderung committet ist. Nur claude-code hat eine solche Datei und nur an einem
+Arbeitsverzeichnis. Gearbeitet wird in zwei Schritten, erst eintragen, dann entfernen: bricht der
+zweite ab, steht der Eintrag doppelt statt gar nicht mehr, und die Meldung sagt, was zu tun bleibt.
+
+Nach dem Einhängen/Aushängen nennt hmgr den Weg zur Wirkung: Claude Code übernimmt die Änderung erst
+mit der nächsten Sitzung, Hermes lädt seine config.yaml selbst nach, dafür gibt es keinen Hinweis.
+
+Fehlende \${VAR}-Verweise beim Einhängen sind kein Abbruch, nur eine Warnung (F39): hmgr kann nicht
+wissen, was die Shell beim Start des Harness setzt. Geprüft wird gegen die eigene Prozess-Umgebung
+und, bei einem Hermes-Ziel, zusätzlich gegen <hermes-home>/.env.
+
+Schalter (add, remove und migrate):
+  --harness <name>    claude-code oder hermes, Standard claude-code
+  --ort <ort>         home, dir:<pfad> oder profil:<name>, Standard home
+
+Beispiele:
+  hmgr mcp list
+  hmgr mcp add teamwork --ort dir:.
+  hmgr mcp add context7 --harness hermes --ort profil:researcher
+  hmgr mcp remove teamwork --ort dir:.
+  hmgr mcp migrate kollegen-tool --ort dir:.
+
+Häufige Fälle:
+  „steht nicht im Katalog": hmgr mcp list zeigt die bekannten Namen, ~/.hmgr/mcp.yaml pflegt sie.
+  „kennt keine MCP-Server": nur claude-code und hermes haben diese Fähigkeit, agents nicht.
+  „kennt für MCP-Server den Ort … nicht – Hermes kennt keine Projektebene für MCPs": bei Hermes
+  --ort home oder --ort profil:<name> nutzen, kein dir:<pfad>.
+  „liegt schon ein MCP-Server …, der nicht von hmgr stammt oder vom Katalogblock abweicht": von Hand
+  angleichen oder hmgr mcp remove, dann erneut versuchen.
+  „steht in der geteilten …/.mcp.json": mcp remove fasst sie nicht an, hmgr mcp migrate <name> holt
+  den Eintrag in den privaten Scope und löscht ihn aus der Datei.
+  „gibt es keine geteilte Konfigurationsdatei": mcp migrate geht nur mit --harness claude-code und
+  --ort dir:<pfad>.
+
+Siehe auch: hmgr help harness, hmgr help status`;
 const SYNC = `hmgr sync [pfad]
 
 Bringt ein Arbeitsverzeichnis auf den Stand seines Zeigers: fehlende Quellen übernehmen, fehlende
@@ -256,6 +439,18 @@ Plugin-Fähigkeit deren Plugins nach (E14). Die Links zeigen weiter auf dieselbe
 nicht erneuert werden. Ein Checkout mit lokaler Änderung wird übersprungen und gemeldet (E15),
 damit nichts verloren geht. Lokale Quellen haben keinen Checkout und bleiben unberührt.
 
+Unter jeder „aktualisiert"-Zeile steht, welche Skills der neue Stand geändert hat (E70): die Namen
+kommen aus dem Vergleich von altem und neuem Commit, gezählt werden nur Skills, die in diesem
+Checkout auch ausgecheckt sind. Berührt ein Commit nur Dateien daneben (README, CI), bleibt die
+Zeile weg.
+
+Im selben Lauf gleicht update die installierten Bundles gegen ihre Definitionen ab (E69): eine
+Definition, die inzwischen ein Mitglied mehr oder weniger nennt, wird in jedem Ziel nachgezogen, in
+dem das Bundle hängt. Das ist der Weg, auf dem eine Bundle-Änderung aus einer Quelle ankommt — ohne
+ihn müsste man von seinen eigenen Änderungen wissen, um sie zu holen. Was sich nicht vollständig
+nachziehen lässt, bleibt in seinem Ziel auf dem alten Stand und wird als fehlgeschlagen gemeldet,
+ohne den übrigen Lauf aufzuhalten. hmgr bundle sync macht dasselbe für ein einzelnes Bundle.
+
 Danach räumt update verwaiste Ref-Verzeichnisse auf: Checkouts, in die kein Link mehr zeigt, weil
 ein Link inzwischen auf einen anderen Ref umgelegt wurde. Vor dem Löschen fragt hmgr einmal für
 alle Kandidaten. Ohne Bestätigung, also auch ohne Terminal, bleibt alles liegen und wird nur
@@ -359,6 +554,8 @@ const THEMEN = new Map([
     ['unlink', UNLINK],
     ['adopt', ADOPT],
     ['plugin', PLUGIN],
+    ['bundle', BUNDLE],
+    ['mcp', MCP],
     ['sync', SYNC],
     ['update', UPDATE],
     ['status', STATUS],

package/dist/cli/main.js

@@ -4,16 +4,19 @@ 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, 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";
 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";
 import { ZustandJson } from "../adapter/zustand-json.js";
 import { HILFE, hilfeText } from "./hilfe.js";
 export function umgebungLesen(env = process.env) {
@@ -38,6 +41,8 @@ export function bauen(umgebung, optionen = {}) {
         zeiger: new ComposerZeiger(),
         zustand,
         rueckfrage: optionen.rueckfrage ?? new TerminalRueckfrage(),
+        mcpKatalog: new DateiMcpKatalog(path.join(umgebung.hmgrHome, 'mcp.yaml')),
+        umgebung: optionen.umgebung ?? new ProzessUmgebung(),
     };
     return { anwendungsfaelle: new Anwendungsfaelle(ports), ports };
 }
@@ -55,6 +60,8 @@ 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: [] },
     status: { werte: [], flaggen: [] },
@@ -82,6 +89,20 @@ 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'] },
+        // Übernehmen (E64): dieselben Ziel-Schalter wie add und remove.
+        migrate: { woerter: 2, schalter: ['harness', 'ort'] },
+        list: { woerter: 1, schalter: [] },
+    },
     harness: {
         list: { woerter: 1, schalter: [] },
         enable: { woerter: 2, schalter: [] },
@@ -167,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);
@@ -207,7 +233,7 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
                 console.log(quelleAlsText(quelle) === quelleAlsText(genannt)
                     ? 'Quelle ist schon bekannt, keine zweite angelegt.'
                     : `Quelle ist schon bekannt, geführt als ${quelleAlsText(quelle)}. Keine zweite angelegt.`);
-            console.log(`Quelle ${quelleAlsText(quelle)} (${quelle.art}) als „${quelleName(quelle)}", ${skills.length} Skills:`);
+            console.log(`Quelle ${quelleAlsText(quelle)} (${quelle.art}) als „${quelleName(quelle)}", ${skills.length} ${skills.length === 1 ? 'Skill' : 'Skills'}:`);
             for (const skill of skills) {
                 const beschreibung = skill.beschreibung === undefined ? '' : `  ${kappen(skill.beschreibung)}`;
                 console.log(`  ${skill.name}  ${skill.pfad}${beschreibung}`);
@@ -365,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;
@@ -478,6 +507,147 @@ 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);
+        const { rest, werte } = schalter;
+        const unterkommando = rest[0];
+        if (unterkommando === 'list') {
+            const uebersicht = await anwendungsfaelle.mcpUebersicht();
+            if (uebersicht.katalog.length === 0)
+                console.log('Kein MCP im Katalog. hmgr help mcp zeigt das Format von ~/.hmgr/mcp.yaml.');
+            for (const { eintrag, eingehaengt, geteilteFundorte } of uebersicht.katalog) {
+                console.log(`${eintrag.name}  ${eintrag.beschreibung}`);
+                if (eingehaengt.length === 0 && geteilteFundorte.length === 0)
+                    console.log('  nirgends eingehängt');
+                for (const ziel of eingehaengt)
+                    console.log(`  ${ziel.harness}  ${beschreibeOrt(ziel.ort)}`);
+                // Geteilte, nur lesbare Fundorte (E61-Nachtrag): eigens gekennzeichnet, hmgr fasst sie nicht an.
+                for (const f of geteilteFundorte)
+                    console.log(`  ${f.ziel.harness}  ${beschreibeOrt(f.ziel.ort)}  ${f.datei} · Scope ${f.scope} (geteilt, hmgr fasst sie nicht an)`);
+            }
+            if (uebersicht.unbekannt.length > 0 || uebersicht.unbekannteGeteilteFundorte.length > 0) {
+                console.log('Nicht im Katalog, aber eingehängt (hmgr fasst sie nicht an):');
+                for (const { ziel, name } of uebersicht.unbekannt)
+                    console.log(`  ${name}  ${ziel.harness}  ${beschreibeOrt(ziel.ort)}`);
+                for (const f of uebersicht.unbekannteGeteilteFundorte)
+                    console.log(`  ${f.name}  ${f.ziel.harness}  ${beschreibeOrt(f.ziel.ort)}  ${f.datei} · Scope ${f.scope}`);
+            }
+            return 0;
+        }
+        if (unterkommando !== 'add' && unterkommando !== 'remove' && unterkommando !== 'migrate')
+            throw new Error(`${unterkommando === undefined ? 'mcp braucht ein Unterkommando' : `Unbekanntes Unterkommando „${unterkommando}" für mcp`}: mcp add <name>, mcp remove <name>, mcp migrate <name> oder mcp list. hmgr help mcp zeigt Beispiele.`);
+        const name = rest[1];
+        if (name === undefined)
+            throw new Error(`mcp ${unterkommando} braucht einen MCP-Namen. hmgr mcp list zeigt die Katalog-Einträge.`);
+        const ziel = { harness: werte.get('harness') ?? 'claude-code', ort: ortLesen(werte.get('ort')) };
+        // Übernehmen (E64): der Name muss nicht im Katalog stehen, der Block kommt aus der geteilten Datei.
+        if (unterkommando === 'migrate') {
+            const ergebnis = await anwendungsfaelle.mcpUebernehmen({ name, ziel });
+            console.log(`MCP ${ergebnis.name} in den privaten Scope von ${ziel.harness} ${beschreibeOrt(ziel.ort)} übernommen `
+                + `und aus ${ergebnis.datei} entfernt.`);
+            if (ergebnis.hinweis !== undefined)
+                console.log(`  ${ergebnis.hinweis}`);
+            return 0;
+        }
+        if (unterkommando === 'add') {
+            const ergebnis = await anwendungsfaelle.mcpEinhaengen({ name, ziel });
+            console.log(`MCP ${ergebnis.eintrag.name} eingehängt in ${ziel.harness} ${beschreibeOrt(ziel.ort)}.`);
+            if (ergebnis.hinweis !== undefined)
+                console.log(`  ${ergebnis.hinweis}`);
+            if (ergebnis.warnung !== undefined)
+                console.log(`  ${ergebnis.warnung}`);
+            return 0;
+        }
+        const ergebnis = await anwendungsfaelle.mcpAushaengen({ name, ziel });
+        console.log(`MCP ${ergebnis.eintrag.name} ausgehängt aus ${ziel.harness} ${beschreibeOrt(ziel.ort)}.`);
+        if (ergebnis.hinweis !== undefined)
+            console.log(`  ${ergebnis.hinweis}`);
+        return 0;
+    }
     if (kommando === 'sync') {
         const { rest } = schalterLesen(argv.slice(1), 'sync');
         restPruefen(rest, 1, 'sync');
@@ -498,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')
@@ -514,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}`;
@@ -548,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(', ')}`);
         }
@@ -668,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')
@@ -691,6 +897,7 @@ function beschreibeOrt(ort) {
 }
 function istModellFehler(fehler) {
     return (fehler instanceof NameBelegt ||
+        fehler instanceof LinkAnlegenFehlgeschlagen ||
         fehler instanceof SkillMehrdeutig ||
         fehler instanceof SkillUnbekannt ||
         fehler instanceof OrtNichtUnterstuetzt ||
@@ -703,13 +910,28 @@ 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 ||
         fehler instanceof SkillOrdnerFaehigkeitFehlt ||
         fehler instanceof SkillOrdnerBereitsVerwaltet ||
         fehler instanceof SkillOrdnerNichtVerwaltet ||
-        fehler instanceof SkillOrdnerUngueltig);
+        fehler instanceof SkillOrdnerUngueltig ||
+        fehler instanceof McpUnbekannt ||
+        fehler instanceof McpFaehigkeitFehlt ||
+        fehler instanceof McpEbeneNichtUnterstuetzt ||
+        fehler instanceof McpAbweichenderEintrag ||
+        fehler instanceof McpKatalogFehler ||
+        fehler instanceof McpNurGeteilterFundort ||
+        fehler instanceof McpUebernahmeNichtMoeglich ||
+        fehler instanceof McpNichtInGeteilterDatei ||
+        fehler instanceof McpUebernahmeUnvollstaendig);
 }
 /**
  * Der nächste Schritt zu einem Fehler aus dem Kern. Die Fehlertexte selbst bleiben, wie das Modell
@@ -728,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)
@@ -752,6 +986,20 @@ function naechsterSchritt(fehler) {
         return fehler.grund === 'ausserhalb'
             ? 'Der Pfad muss unterhalb des Hermes-Home liegen.'
             : 'Das ist Hermes\' eigener Skill-Ordner, ein anderer Pfad muss her.';
+    if (fehler instanceof McpUnbekannt)
+        return 'hmgr mcp list zeigt die Katalog-Einträge. Gepflegt wird der Katalog in ~/.hmgr/mcp.yaml, hmgr help mcp zeigt das Format.';
+    if (fehler instanceof McpFaehigkeitFehlt)
+        return 'Nur claude-code und hermes kennen MCP-Server.';
+    if (fehler instanceof McpEbeneNichtUnterstuetzt)
+        return 'claude-code kennt --ort home und --ort dir:<pfad>, hermes --ort home und --ort profil:<name>.';
+    if (fehler instanceof McpAbweichenderEintrag)
+        return 'Erst von Hand angleichen oder mit hmgr mcp remove entfernen, dann erneut versuchen.';
+    if (fehler instanceof McpKatalogFehler)
+        return '~/.hmgr/mcp.yaml prüfen und korrigieren, hmgr help mcp zeigt das Format.';
+    if (fehler instanceof McpUebernahmeNichtMoeglich)
+        return 'Eine geteilte .mcp.json kennt nur claude-code, und nur an einem Arbeitsverzeichnis: --harness claude-code --ort dir:<pfad>.';
+    if (fehler instanceof McpNichtInGeteilterDatei)
+        return 'hmgr mcp list zeigt, welche Namen dort stehen; mcp migrate übernimmt nur Einträge aus der geteilten Datei.';
     return undefined;
 }
 export async function main(argv, umgebung) {