hmgr 0.0.6 → 0.0.7

package/dist/adapter/bundle-yaml.js

@@ -0,0 +1,87 @@
+// Liest eine Bundle-Definition aus einer Quelle (E69). hmgr schreibt solche Dateien nie.
+import { parseDocument } from 'yaml';
+import { BundleDateiFehler } from "../kern/modell.js";
+import { quelleAusText } from "./quelle-text.js";
+/** Konvention für Bundle-Definitionen in einer Quelle (E69): `bundles/<name>.yaml`. */
+export const BUNDLE_VERZEICHNIS = 'bundles';
+/**
+ * Ob ein Pfad in der Quelle eine Bundle-Definition ist: eine Datei direkt unter `bundles/`, mit
+ * Endung `.yaml` oder `.yml`. Nichts Verschachteltes — die Konvention nennt genau eine Ebene, und
+ * ein Unterordner wäre eine stille zweite Bedeutung.
+ */
+export function istBundleDatei(pfad) {
+    return /^bundles\/[^/]+\.(?:yaml|yml)$/.test(pfad);
+}
+/** Der Dateiname ohne Verzeichnis und Endung: Ersatzname, wenn das Feld `name` fehlt. */
+export function bundleDateiName(pfad) {
+    return pfad.replace(/^bundles\//, '').replace(/\.(?:yaml|yml)$/, '');
+}
+function fehlertext(fehler) {
+    return fehler instanceof Error ? fehler.message : String(fehler);
+}
+function istObjekt(wert) {
+    return typeof wert === 'object' && wert !== null && !Array.isArray(wert);
+}
+/** Erlaubte Felder auf oberster Ebene und je Mitglied. Alles andere ist ein Fehler mit Feldnamen. */
+const FELDER = new Set(['name', 'description', 'skills']);
+const MITGLIED_FELDER = new Set(['source', 'path']);
+function mitgliedLesen(datei, roh, i) {
+    if (!istObjekt(roh))
+        throw new BundleDateiFehler(datei, `skills[${i}] muss ein Objekt mit source und path sein`);
+    for (const feld of Object.keys(roh))
+        if (!MITGLIED_FELDER.has(feld))
+            throw new BundleDateiFehler(datei, `skills[${i}]: unbekanntes Feld „${feld}"`);
+    const source = roh['source'];
+    if (typeof source !== 'string' || source.trim().length === 0)
+        throw new BundleDateiFehler(datei, `skills[${i}].source muss die Adresse einer Quelle sein (URL oder Pfad)`);
+    const pfad = roh['path'];
+    if (typeof pfad !== 'string' || pfad.trim().length === 0)
+        throw new BundleDateiFehler(datei, `skills[${i}].path muss der Pfad des Skills in der Quelle sein`);
+    // Führende und abschließende Schrägstriche fallen weg: `skills/x/` und `skills/x` meinen denselben
+    // Ordner, und der Katalog führt ihn ohne (E11). Ein Wurzel-Skill (leerer Pfad) ist nicht
+    // adressierbar — er hieße in der Definition „", das ist kein Text und fliegt oben schon auf.
+    return { quelle: quelleAusText(source.trim()), pfad: pfad.trim().replace(/^\/+/, '').replace(/\/+$/, '') };
+}
+/**
+ * Eine Bundle-Definition aus dem YAML-Text lesen und validieren (E69). `datei` ist der Pfad in der
+ * Quelle, er dient als Ersatzname (ohne Verzeichnis und Endung), wenn das Feld `name` fehlt: der
+ * Dateiname ist Konvention, das Feld ist die Aussage des Autors — dieselbe Rangfolge wie beim
+ * Skill-Namen (E32). `quelle` ist die Quelle, in der die Datei liegt.
+ */
+export function bundleLesen(text, datei, quelle) {
+    let daten;
+    try {
+        const dokument = parseDocument(text, { strict: true });
+        // `parseDocument` sammelt Syntaxfehler, statt zu werfen: ohne diese Prüfung käme eine kaputte
+        // Datei als halb gelesenes Objekt durch und der Nutzer bekäme eine Meldung über ein Feld statt
+        // über die Datei.
+        const erster = dokument.errors[0];
+        if (erster !== undefined)
+            throw new BundleDateiFehler(datei, `kaputtes YAML: ${erster.message}`);
+        daten = dokument.toJS();
+    }
+    catch (fehler) {
+        if (fehler instanceof BundleDateiFehler)
+            throw fehler;
+        throw new BundleDateiFehler(datei, `kaputtes YAML: ${fehlertext(fehler)}`);
+    }
+    if (!istObjekt(daten))
+        throw new BundleDateiFehler(datei, 'die Datei muss ein Objekt mit name, description und skills sein');
+    for (const feld of Object.keys(daten))
+        if (!FELDER.has(feld))
+            throw new BundleDateiFehler(datei, `unbekanntes Feld „${feld}"`);
+    const rohName = daten['name'];
+    if (rohName !== undefined && (typeof rohName !== 'string' || rohName.trim().length === 0))
+        throw new BundleDateiFehler(datei, 'name muss nicht leerer Text sein');
+    const name = typeof rohName === 'string' ? rohName.trim() : bundleDateiName(datei);
+    const beschreibung = daten['description'];
+    if (typeof beschreibung !== 'string' || beschreibung.trim().length === 0)
+        throw new BundleDateiFehler(datei, 'description muss nicht leerer Text sein');
+    const skills = daten['skills'];
+    if (!Array.isArray(skills))
+        throw new BundleDateiFehler(datei, 'skills muss eine Liste sein');
+    if (skills.length === 0)
+        throw new BundleDateiFehler(datei, 'skills darf nicht leer sein');
+    const mitglieder = skills.map((roh, i) => mitgliedLesen(datei, roh, i));
+    return { name, beschreibung: beschreibung.trim(), mitglieder, quelle, datei };
+}

package/dist/adapter/git.js

@@ -2,6 +2,7 @@
 import { spawn } from 'node:child_process';
 import { readFile, readdir, mkdir, realpath, rm, stat } from 'node:fs/promises';
 import path from 'node:path';
+import { bundleLesen, istBundleDatei } from "./bundle-yaml.js";
 import { marketplaceLesen } from "./marketplace-json.js";
 import { SKILL_DATEI, skillAusPfad, skillName } from "./skill-md.js";
 import { BASIS_NAME, basisPfad, quelleZerlegen, refDekodieren, worktreePfad } from "./checkout-pfad.js";
@@ -253,6 +254,55 @@ export class GitQuellen {
             })),
         };
     }
+    /**
+     * Inhalte beliebiger Dateien eines Refs in einem Aufruf, dasselbe Bündel-Muster wie
+     * `skillMdInhalte`: `git cat-file --batch` holt beim Partial Clone die fehlenden Blobs gebündelt.
+     * Was nicht lesbar ist, fehlt in der Karte.
+     */
+    async dateiInhalte(basis, ref, pfade) {
+        if (pfade.length === 0)
+            return new Map();
+        const eingabe = `${pfade.map((p) => `${ref}:${p}`).join('\n')}\n`;
+        const ausgabe = await this.gitMitEingabe(['cat-file', '--batch'], basis, eingabe).catch(() => undefined);
+        if (ausgabe === undefined)
+            return new Map();
+        return batchInhalte(ausgabe, pfade);
+    }
+    /**
+     * Bundle-Definitionen der Quelle (E69): jede Datei unter `bundles/`, gelesen wie der Marketplace
+     * über den Git-Baum statt über einen Checkout. Eine kaputte Datei ergibt einen Fehler-Eintrag,
+     * keinen Abbruch: die übrigen Bundles derselben Quelle bleiben nutzbar.
+     */
+    async bundles(quelle, ref) {
+        let dateien;
+        let inhalte;
+        if (quelle.art === 'lokal') {
+            dateien = (await dateienAufPlatte(quelle.pfad)).filter(istBundleDatei).sort();
+            inhalte = new Map();
+            for (const datei of dateien) {
+                const roh = await readFile(path.join(quelle.pfad, datei), 'utf8').catch(() => undefined);
+                if (roh !== undefined)
+                    inhalte.set(datei, roh);
+            }
+        }
+        else {
+            const basis = await this.basis(quelle);
+            const ausgabe = await this.git(['ls-tree', '-r', '--name-only', ref], basis);
+            dateien = ausgabe.split('\n').filter(istBundleDatei).sort();
+            inhalte = await this.dateiInhalte(basis, ref, dateien);
+        }
+        return dateien.map((datei) => {
+            const inhalt = inhalte.get(datei);
+            if (inhalt === undefined)
+                return { art: 'fehler', datei, fehler: 'Datei nicht lesbar' };
+            try {
+                return { art: 'bundle', datei, bundle: bundleLesen(inhalt, datei, quelle) };
+            }
+            catch (fehler) {
+                return { art: 'fehler', datei, fehler: fehler instanceof Error ? fehler.message : String(fehler) };
+            }
+        });
+    }
     async refs(quelle) {
         if (quelle.art === 'lokal')
             return [LOKAL_REF];
@@ -374,6 +424,104 @@ export class GitQuellen {
         await this.git(['checkout', '--detach', checkout.ref], checkout.pfad);
         return { ergebnis: 'aktualisiert', von, nach };
     }
+    /**
+     * Geänderte Pfade zwischen zwei Commits (E70). `--no-renames` aus zwei Gründen: eine Umbenennung
+     * soll hier als Änderung an beiden Pfaden zählen, und die Ähnlichkeitsprüfung bräuchte die Blobs,
+     * die ein Partial Clone (`--filter=blob:none`) erst aus dem Netz holen müsste. Eine lokale Quelle
+     * hat keinen Checkout und damit keine zwei Commits (B11), sie kommt hier nie an.
+     */
+    async geaenderteDateien(quelle, von, nach) {
+        if (quelle.art === 'lokal')
+            return [];
+        try {
+            const basis = await this.basis(quelle);
+            const ausgabe = await this.git(['diff', '--name-only', '--no-renames', von, nach], basis);
+            return ausgabe.split('\n').filter((z) => z.length > 0);
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Skills, die in diesem Checkout auf der Platte liegen (E70): dieselbe Regel wie bei einer
+     * lokalen Quelle, nur auf das Worktree-Verzeichnis angewandt. Der Sparse-Checkout hat dort nur
+     * die gewählten Skills materialisiert (E22), also nennt der Update-Bericht auch nur diese.
+     */
+    async ausgecheckteSkills(checkout) {
+        const pfade = skillPfadeAusDateien(await dateienAufPlatte(checkout.pfad));
+        const inhalte = await inhalteAufPlatte(checkout.pfad, pfade);
+        const ersatzname = ersatznameDerQuelle(checkout.quelle);
+        return pfade.map((pfad) => skillAusPfad(pfad, inhalte.get(pfad), ersatzname));
+    }
+    /**
+     * Ein `git log --name-only` je Quelle statt eines Aufrufs je Skill (E70). Die Ausgabe wird
+     * gelesen, während sie entsteht, und der Lauf abgebrochen, sobald jeder gesuchte Pfad sein Datum
+     * hat: der jüngste Commit steht vorn, alles Ältere ist unnötig. Gemessen an einem Repo mit 20
+     * Skills und 401 Commits: 6 ms gegen 110 ms für 20 einzelne `git log -1`.
+     *
+     * Format: `%x00%cI` stellt jeder Datumszeile ein NUL voran, das in keinem Dateipfad vorkommt —
+     * daran trennen sich Kopf und Dateiliste. `--no-renames` hält die Ähnlichkeitsprüfung heraus, die
+     * beim Partial Clone Blobs nachladen würde. Scheitert der Aufruf (kein Repo, unbekannter Ref),
+     * bleibt die Karte leer, das ist kein Fehler.
+     */
+    async logDaten(cwd, ref, pfade) {
+        const daten = new Map();
+        const offen = new Set(pfade);
+        if (offen.size === 0)
+            return daten;
+        return await new Promise((erfuellen) => {
+            const kind = spawn('git', ['log', '--format=%x00%cI', '--name-only', '--no-renames', ref], {
+                cwd,
+                stdio: ['ignore', 'pipe', 'ignore'],
+                timeout: 300_000,
+                killSignal: 'SIGKILL',
+                env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+            });
+            let rest = '';
+            let datum;
+            const fertig = () => erfuellen(daten);
+            kind.on('error', fertig);
+            kind.on('close', fertig);
+            // Nach dem Abbruch schreibt git in eine Pipe, die niemand mehr liest: der Fehler darf den
+            // Prozess nicht mitnehmen, das Ergebnis steht da schon fest.
+            kind.stdout.on('error', () => { });
+            kind.stdout.on('data', (teil) => {
+                rest += teil.toString('utf8');
+                const zeilen = rest.split('\n');
+                rest = zeilen.pop() ?? '';
+                for (const zeile of zeilen) {
+                    if (zeile.startsWith('\0')) {
+                        datum = zeile.slice(1);
+                        continue;
+                    }
+                    if (zeile.length === 0 || datum === undefined)
+                        continue;
+                    for (const pfad of [...offen])
+                        // Ein Wurzel-Skill (Pfad `''`, E11-Nachtrag) ist das ganze Repo: jede Datei zählt.
+                        if (pfad === '' || zeile === pfad || zeile.startsWith(`${pfad}/`)) {
+                            daten.set(pfad, datum);
+                            offen.delete(pfad);
+                        }
+                }
+                if (offen.size === 0)
+                    kind.kill('SIGTERM');
+            });
+        });
+    }
+    /**
+     * Änderungsdatum je Skill (E70, F70=O1). Eine lokale Quelle hat keinen Basis-Clone, wohl aber
+     * meist eine Arbeitskopie (B11): dort zählt der HEAD-Stand auf der Platte, wie überall sonst bei
+     * lokalen Quellen. Ist der Pfad kein Git-Repo, bleibt die Karte leer und der Katalog nennt für
+     * diese Quelle kein Datum.
+     */
+    async letzteAenderungen(quelle, ref, pfade) {
+        if (quelle.art === 'lokal')
+            return await this.logDaten(quelle.pfad, 'HEAD', pfade);
+        const basis = await this.basis(quelle).catch(() => undefined);
+        if (basis === undefined)
+            return new Map();
+        return await this.logDaten(basis, ref, pfade);
+    }
     /**
      * Checkout von der Platte nehmen. Ein Worktree steht im Basis-Clone eingetragen, ein blankes
      * Löschen des Verzeichnisses ließe den Eintrag stehen und ein späterer `worktree add` auf

package/dist/adapter/paket-version.js

@@ -0,0 +1,25 @@
+// Die Version des Pakets, gelesen aus seiner package.json (E72). Keine Kopie im Code: eine
+// zweite Stelle mit derselben Zahl geht früher oder später auseinander.
+import { readFileSync } from 'node:fs';
+/**
+ * Die package.json liegt in jeder Lage zwei Ebenen über diesem Modul: in der Quelle
+ * `src/adapter/` → Wurzel, im Build `dist/adapter/` → Wurzel, in der npm-Installation
+ * `node_modules/hmgr/dist/adapter/` → `node_modules/hmgr/`, im gepackten App-Bundle
+ * `app.asar/dist/adapter/` → `app.asar/`. Aufgelöst über `import.meta.url`, damit weder das
+ * Arbeitsverzeichnis noch der Aufrufweg hineinspielt.
+ *
+ * Bewusst kein Import mit `with { type: 'json' }`: der zöge die package.json beim Bauen nach
+ * `dist` und legte damit eine zweite Wahrheit an.
+ */
+const PAKET_JSON = new URL('../../package.json', import.meta.url);
+let gemerkt;
+/** Die Versionsnummer aus der package.json des Pakets, etwa „0.0.6". */
+export function paketVersion() {
+    if (gemerkt === undefined) {
+        const inhalt = JSON.parse(readFileSync(PAKET_JSON, 'utf8'));
+        if (typeof inhalt.version !== 'string')
+            throw new Error(`Die package.json unter ${PAKET_JSON.pathname} nennt keine Version.`);
+        gemerkt = inhalt.version;
+    }
+    return gemerkt;
+}

package/dist/adapter/zustand-json.js

@@ -1,7 +1,7 @@
 // Lokaler Zustand als eine JSON-Datei, Standard ~/.hmgr/state.json (E29).
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
-import { leererZustand } from "../ports/zustand.js";
+import { ZUSTAND_FASSUNG, leererZustand, } from "../ports/zustand.js";
 import { ohneBom } from "./datei-text.js";
 export class ZustandJson {
     pfad;
@@ -14,6 +14,9 @@ export class ZustandJson {
             return leererZustand();
         const daten = JSON.parse(ohneBom(roh));
         return {
+            // Fehlt das Feld (state.json vor E69), ist es die erste Fassung: alles ohne Bundles.
+            // Geschrieben wird danach in der aktuellen Fassung, ein Rückweg ist nicht vorgesehen.
+            fassung: typeof daten.fassung === 'number' ? daten.fassung : 1,
             quellen: (daten.quellen ?? []),
             arbeitsverzeichnisse: (daten.arbeitsverzeichnisse ?? []),
             bindungen: (daten.bindungen ?? []),
@@ -21,10 +24,14 @@ export class ZustandJson {
             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.
+            bundleInstallationen: (daten.bundleInstallationen ?? []),
         };
     }
     async schreiben(zustand) {
         await mkdir(path.dirname(this.pfad), { recursive: true });
-        await writeFile(this.pfad, `${JSON.stringify(zustand, null, 2)}\n`);
+        // Immer in der aktuellen Fassung, egal welche gelesen wurde: das Lesen hat den Bestand schon
+        // auf die aktuelle Form gebracht, ein alter Vermerk in der Datei wäre danach eine Lüge.
+        await writeFile(this.pfad, `${JSON.stringify({ ...zustand, fassung: ZUSTAND_FASSUNG }, null, 2)}\n`);
     }
 }

package/dist/cli/hilfe.js

@@ -22,6 +22,10 @@ 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
@@ -33,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>]
@@ -230,6 +235,87 @@ 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]
@@ -353,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
@@ -456,6 +554,7 @@ const THEMEN = new Map([
     ['unlink', UNLINK],
     ['adopt', ADOPT],
     ['plugin', PLUGIN],
+    ['bundle', BUNDLE],
     ['mcp', MCP],
     ['sync', SYNC],
     ['update', UPDATE],