hmgr 0.0.45 → 0.0.47

package/dist/adapter/git.js

@@ -1,7 +1,9 @@
 // Git über die CLI, keine Bibliothek. Checkout-Schema und Worktrees nach E22, Discovery nach E11.
 import { spawn } from 'node:child_process';
-import { readFile, readdir, mkdir, realpath, rm, stat } from 'node:fs/promises';
+import { readFile, readdir, mkdir, realpath, rm, stat, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
 import path from 'node:path';
+import { SOPS_FILTER, SOPS_MARKE, checkAttrLesen, filterBefehle, musterAuswahl, probe, sopsFehlertext, standardSops, wrapperFinden, } from "./sops.js";
 import { bundleLesen, istBundleDatei } from "./bundle-yaml.js";
 import { marketplaceLesen } from "./marketplace-json.js";
 import { SKILL_DATEI, skillAusPfad, skillName } from "./skill-md.js";
@@ -131,9 +133,11 @@ const SPERRE_BELEGT = /Unable to create '[^']+\.lock': File exists/;
 export class GitQuellen {
     wurzel;
     sperreWartezeitenMs;
+    sops;
     constructor(wurzel, optionen = {}) {
         this.wurzel = wurzel;
         this.sperreWartezeitenMs = optionen.sperreWartezeitenMs ?? SPERRE_WARTEZEITEN_MS;
+        this.sops = optionen.sops ?? standardSops(homedir());
     }
     /**
      * Wiederholt einen git-Aufruf, wenn eine fremde Sperre ihn blockiert (E99): GUI-Aktionen und der
@@ -379,15 +383,10 @@ export class GitQuellen {
     async checkout(quelle, ref, skills) {
         // Lokale Quellen werden nicht geklont, der Pfad selbst ist der Checkout (B11).
         if (quelle.art === 'lokal')
-            return { quelle, ref, pfad: quelle.pfad };
+            return { quelle, ref, pfad: quelle.pfad, sopsVerschluesselt: [] };
         const basis = await this.basis(quelle);
         const pfad = worktreePfad(this.wurzel, quelleZerlegen(quelle), ref);
         const neu = !(await existiert(pfad));
-        if (neu) {
-            await mkdir(path.dirname(pfad), { recursive: true });
-            await this.git(['worktree', 'add', '--detach', '--no-checkout', pfad, ref], basis);
-            await this.git(['sparse-checkout', 'init', '--no-cone'], pfad);
-        }
         const vorhanden = neu
             ? []
             : (await this.git(['sparse-checkout', 'list'], pfad)).split('\n').filter((z) => z.length > 0);
@@ -404,10 +403,201 @@ export class GitQuellen {
         // stört nicht — wohl aber sähe ein Nutzer, der den Link im Finder öffnet, den vollen Worktree.
         for (const skill of skills)
             muster.add(skill.pfad === '' ? '/**' : `/${skill.pfad}/`);
+        // SOPS-Filter vor dem ersten Schreiben (E115): `sparse-checkout set` und `checkout` schreiben
+        // die Dateien, ein später gesetzter Filter ändert an ihnen nichts mehr. Ein bestehender
+        // Worktree steht auf seinem eigenen HEAD, ein neuer kommt auf `ref`.
+        const sopsVerschluesselt = await this.sopsVorbereiten(neu ? basis : pfad, neu ? ref : 'HEAD', basis, muster);
+        if (neu) {
+            await mkdir(path.dirname(pfad), { recursive: true });
+            await this.git(['worktree', 'add', '--detach', '--no-checkout', pfad, ref], basis);
+            await this.git(['sparse-checkout', 'init', '--no-cone'], pfad);
+        }
         await this.git(['sparse-checkout', 'set', '--no-cone', '--', ...muster], pfad);
         if (neu)
             await this.git(['checkout', '--detach', ref], pfad);
-        return { quelle, ref, pfad };
+        return { quelle, ref, pfad, sopsVerschluesselt };
+    }
+    /**
+     * Dateien eines Refs unter einem SOPS-Filter, den hmgr kennt (E115), beschränkt auf `auswahl`.
+     * Der Normalfall kostet einen `ls-tree`: ohne `.gitattributes`, die für eine gewählte Datei
+     * gelten kann, oder ohne „sops_" darin endet die Suche dort. Erst dann `check-attr`, mit
+     * `--source` (git ≥ 2.40), weil der Basis-Clone bare ist und ein neuer Worktree noch leer.
+     * Scheitert ein Aufruf (etwa ein älteres git), gilt die Liste als leer: dann bleibt es beim
+     * Auschecken wie vor E115.
+     */
+    async sopsKandidaten(cwd, ref, auswahl) {
+        try {
+            const alle = (await this.git(['ls-tree', '-r', '-z', '--name-only', ref], cwd)).split('\0').filter((z) => z.length > 0);
+            const istAttribute = (d) => d === '.gitattributes' || d.endsWith('/.gitattributes');
+            const gewaehlt = alle.filter((d) => auswahl(d) && !istAttribute(d));
+            if (gewaehlt.length === 0)
+                return [];
+            // Eine .gitattributes gilt für ihr Verzeichnis und alles darunter.
+            const attribute = alle.filter((d) => {
+                if (!istAttribute(d))
+                    return false;
+                const verzeichnis = d.slice(0, -'.gitattributes'.length);
+                return gewaehlt.some((g) => g.startsWith(verzeichnis));
+            });
+            if (attribute.length === 0)
+                return [];
+            const inhalte = await this.dateiInhalte(cwd, ref, attribute);
+            if (![...inhalte.values()].some((text) => text.includes('sops_')))
+                return [];
+            const ausgabe = await this.gitMitEingabe(['check-attr', `--source=${ref}`, '-z', '--stdin', 'filter'], cwd, `${gewaehlt.join('\0')}\0`);
+            const werte = checkAttrLesen(ausgabe.toString('utf8'));
+            return gewaehlt
+                .map((datei) => ({ datei, filter: werte.get(datei) ?? '' }))
+                .filter((k) => SOPS_FILTER.includes(k.filter));
+        }
+        catch {
+            return [];
+        }
+    }
+    /** Ob `filter.<name>.smudge` wirksam gesetzt ist, global oder im Basis-Clone (E115). */
+    async filterGesetzt(basis, name) {
+        const wert = await this.git(['config', '--get', `filter.${name}.smudge`], basis).catch(() => '');
+        return wert.trim().length > 0;
+    }
+    /** Filter wie sops-setup.sh im Basis-Clone setzen; er gilt für alle Worktrees der Quelle (E115). */
+    async filterSetzen(basis, namen, wrapper) {
+        const { clean, smudge } = filterBefehle(this.sops.programm, wrapper);
+        for (const name of namen) {
+            await this.git(['config', `filter.${name}.clean`, clean], basis);
+            await this.git(['config', `filter.${name}.smudge`, smudge], basis);
+            await this.git(['config', `filter.${name}.required`, 'true'], basis);
+        }
+    }
+    /**
+     * Probe über alle Dateien, Abbruch beim ersten Fehlschlag (E115): nur wenn alle klappen, kommen
+     * Filter in Frage. Ein Fehlschlag gilt für alle, denn ohne Filter bleiben alle verschlüsselt.
+     */
+    async sopsProbe(cwd, ref, dateien) {
+        const inhalte = await this.dateiInhalte(cwd, ref, dateien);
+        for (const datei of dateien) {
+            const inhalt = inhalte.get(datei);
+            if (inhalt === undefined)
+                return 'entschluesselung-scheitert';
+            const ergebnis = await probe(this.sops.programm, datei, inhalt);
+            if (!ergebnis.ok)
+                return ergebnis.grund;
+        }
+        return undefined;
+    }
+    /**
+     * Vor dem Schreiben eines Checkouts (E115): SOPS-Dateien unter den Mustern finden, für Filter,
+     * die noch nicht wirksam sind, die Probe machen und bei Erfolg die Filter setzen. Ein schon
+     * gesetzter Filter (global oder lokal) bleibt unangetastet und braucht keine Probe. Ergebnis:
+     * die Dateien, die verschlüsselt ankommen werden.
+     */
+    async sopsVorbereiten(cwd, ref, basis, muster) {
+        const kandidaten = await this.sopsKandidaten(cwd, ref, musterAuswahl(muster));
+        if (kandidaten.length === 0)
+            return [];
+        const offen = [];
+        for (const name of new Set(kandidaten.map((k) => k.filter)))
+            if (!(await this.filterGesetzt(basis, name)))
+                offen.push(name);
+        if (offen.length === 0)
+            return [];
+        const betroffen = kandidaten.filter((k) => offen.includes(k.filter)).map((k) => k.datei);
+        // Ohne sops-clean.sh keine Filter (F140): git hielte die entschlüsselte Datei sonst sofort für
+        // geändert (echtes `sops --encrypt` verschlüsselt jedes Mal anders). Die Probe entfällt dann.
+        const wrapper = await wrapperFinden(this.sops.wrapperKandidaten);
+        if (wrapper === undefined)
+            return betroffen.map((datei) => ({ datei, grund: 'wrapper-fehlt' }));
+        const grund = await this.sopsProbe(cwd, ref, betroffen);
+        if (grund !== undefined)
+            return betroffen.map((datei) => ({ datei, grund }));
+        await this.filterSetzen(basis, offen, wrapper);
+        return [];
+    }
+    /** SOPS-Dateien eines bestehenden Worktrees samt Inhalt auf der Platte (E115). */
+    async sopsAufPlatte(checkout) {
+        if (checkout.quelle.art === 'lokal' || !(await existiert(checkout.pfad)))
+            return [];
+        const kandidaten = await this.sopsKandidaten(checkout.pfad, 'HEAD', () => true);
+        const ergebnis = [];
+        for (const kandidat of kandidaten) {
+            // Was der Sparse-Checkout nicht geschrieben hat, liegt nicht auf der Platte und zählt nicht.
+            const inhalt = await readFile(path.join(checkout.pfad, kandidat.datei), 'utf8').catch(() => undefined);
+            if (inhalt !== undefined)
+                ergebnis.push({ ...kandidat, inhalt });
+        }
+        return ergebnis;
+    }
+    async sopsDateien(checkout) {
+        return (await this.sopsAufPlatte(checkout)).map((k) => ({
+            datei: k.datei,
+            verschluesselt: k.inhalt.includes(SOPS_MARKE),
+        }));
+    }
+    /**
+     * Bestand (E115): eine SOPS-Datei, die vor E115 verschlüsselt ankam, bleibt so, denn git hält
+     * sie für unverändert. Wo die Probe klappt: Filter setzen (falls noch nicht wirksam), Datei
+     * löschen, `git checkout -- <datei>` schreibt sie durch den smudge-Filter neu. Danach muss sie
+     * Klartext sein und `git status` für sie leer, sonst gilt das Neuschreiben als gescheitert.
+     * Eine Datei, die nicht mehr dem Commit entspricht (von Hand geändert), fasst hmgr nicht an —
+     * verglichen werden die Bytes mit dem Blob, unabhängig von Filtern. Scheitert `checkout`, kommt
+     * der alte Inhalt zurück, damit nie eine Datei fehlt.
+     */
+    async sopsReparieren(checkout) {
+        if (checkout.quelle.art === 'lokal')
+            return [];
+        const verschluesselt = (await this.sopsAufPlatte(checkout)).filter((k) => k.inhalt.includes(SOPS_MARKE));
+        if (verschluesselt.length === 0)
+            return [];
+        const ergebnis = [];
+        const blobs = await this.dateiInhalte(checkout.pfad, 'HEAD', verschluesselt.map((k) => k.datei));
+        const unveraendert = verschluesselt.filter((k) => {
+            if (blobs.get(k.datei) === k.inhalt)
+                return true;
+            ergebnis.push({ datei: k.datei, ergebnis: 'verschluesselt', grund: 'lokale-aenderung' });
+            return false;
+        });
+        if (unveraendert.length === 0)
+            return ergebnis;
+        const basis = await this.basis(checkout.quelle);
+        const offen = [];
+        for (const name of new Set(unveraendert.map((k) => k.filter)))
+            if (!(await this.filterGesetzt(basis, name)))
+                offen.push(name);
+        // Müssen Filter erst gesetzt werden, braucht es sops-clean.sh (F140), sonst bleibt alles, wie es ist.
+        const wrapper = offen.length === 0 ? undefined : await wrapperFinden(this.sops.wrapperKandidaten);
+        if (offen.length > 0 && wrapper === undefined) {
+            for (const k of unveraendert)
+                ergebnis.push({ datei: k.datei, ergebnis: 'verschluesselt', grund: 'wrapper-fehlt' });
+            return ergebnis;
+        }
+        const grund = await this.sopsProbe(checkout.pfad, 'HEAD', unveraendert.map((k) => k.datei));
+        if (grund !== undefined) {
+            for (const k of unveraendert)
+                ergebnis.push({ datei: k.datei, ergebnis: 'verschluesselt', grund });
+            return ergebnis;
+        }
+        if (wrapper !== undefined)
+            await this.filterSetzen(basis, offen, wrapper);
+        for (const k of unveraendert) {
+            const datei = path.join(checkout.pfad, k.datei);
+            try {
+                await rm(datei, { force: true });
+                await this.git(['checkout', '--', k.datei], checkout.pfad);
+            }
+            catch (fehler) {
+                await writeFile(datei, k.inhalt);
+                ergebnis.push({ datei: k.datei, ergebnis: 'fehlgeschlagen', fehler: fehler instanceof Error ? fehler.message : String(fehler) });
+                continue;
+            }
+            const neu = await readFile(datei, 'utf8').catch(() => undefined);
+            const status = await this.git(['--no-optional-locks', 'status', '--porcelain', '--', k.datei], checkout.pfad).catch(() => 'unlesbar');
+            if (neu === undefined || neu.includes(SOPS_MARKE))
+                ergebnis.push({ datei: k.datei, ergebnis: 'fehlgeschlagen', fehler: 'nach dem Neuschreiben noch verschlüsselt' });
+            else if (status.trim().length > 0)
+                ergebnis.push({ datei: k.datei, ergebnis: 'fehlgeschlagen', fehler: 'git meldet die Datei danach als geändert' });
+            else
+                ergebnis.push({ datei: k.datei, ergebnis: 'repariert' });
+        }
+        return ergebnis;
     }
     /**
      * Alle Checkouts unter der Wurzel, aus dem Dateisystem gelesen (E19). Die Quelle kommt aus der
@@ -446,7 +636,15 @@ export class GitQuellen {
     async aktualisieren(checkout) {
         if (checkout.quelle.art === 'lokal')
             return { ergebnis: 'unveraendert' };
-        if (await this.lokaleAenderungen(checkout))
+        // Auch `status` kann an einem SOPS-Filter scheitern (E115): nur dieser Checkout schlägt fehl.
+        let lokalGeaendert;
+        try {
+            lokalGeaendert = await this.lokaleAenderungen(checkout);
+        }
+        catch (fehler) {
+            return { ergebnis: 'fehlgeschlagen', fehler: sopsFehlertext(fehler) };
+        }
+        if (lokalGeaendert)
             return { ergebnis: 'uebersprungen', grund: 'lokale-aenderung' }; // E15
         const basis = await this.basis(checkout.quelle);
         const von = (await this.git(['rev-parse', 'HEAD'], checkout.pfad)).trim();
@@ -460,7 +658,14 @@ export class GitQuellen {
         const nach = (await this.git(['rev-parse', checkout.ref], basis)).trim();
         if (von === nach)
             return { ergebnis: 'unveraendert' };
-        await this.git(['checkout', '--detach', checkout.ref], checkout.pfad);
+        try {
+            await this.git(['checkout', '--detach', checkout.ref], checkout.pfad);
+        }
+        catch (fehler) {
+            // Ein required-Filter, der nicht entschlüsseln kann, bricht das Nachziehen ab (E115). Das
+            // trifft nur diesen Checkout, die übrigen laufen weiter.
+            return { ergebnis: 'fehlgeschlagen', fehler: sopsFehlertext(fehler) };
+        }
         return { ergebnis: 'aktualisiert', von, nach };
     }
     /**

package/dist/adapter/sops.js

@@ -0,0 +1,107 @@
+// SOPS-Filter für Checkouts (E115): Probe-Entschlüsselung, Filterbefehle und das Lesen von
+// `git check-attr`. Die Filter selbst setzt GitQuellen (git.ts) im Basis-Clone; hier liegt nur, was
+// ohne git auskommt. Vorlage der Filterbefehle: sops-setup.sh im Skill sops-secrets-manager.
+import { spawn } from 'node:child_process';
+import { access, constants } from 'node:fs/promises';
+import path from 'node:path';
+/** Die Filternamen, die hmgr kennt und selbst einrichtet (E115). */
+export const SOPS_FILTER = ['sops_dotenv', 'sops_yaml', 'sops_generic'];
+/** Woran hmgr eine noch verschlüsselte SOPS-Datei im Arbeitsbaum erkennt. */
+export const SOPS_MARKE = 'ENC[';
+/** Die Einstellung im Betrieb: sops vom PATH, sops-clean.sh unter /usr/local/bin oder ~/bin. */
+export function standardSops(home) {
+    return {
+        programm: 'sops',
+        wrapperKandidaten: ['/usr/local/bin/sops-clean.sh', path.join(home, 'bin', 'sops-clean.sh')],
+    };
+}
+/**
+ * Ein Wort für die Shell, die git für Filterbefehle startet: unverändert, wenn nichts darin die
+ * Shell stört, sonst in einfachen Anführungszeichen. So bricht ein Home-Pfad mit Leerzeichen nicht.
+ */
+export function shellWort(wert) {
+    if (/^[A-Za-z0-9_@%+=:,./-]+$/.test(wert))
+        return wert;
+    return `'${wert.replace(/'/g, `'\\''`)}'`;
+}
+/** clean- und smudge-Befehl wie sops-setup.sh; `%f` setzt git selbst (schon für die Shell gequotet). */
+export function filterBefehle(programm, wrapper) {
+    const sops = shellWort(programm);
+    const verschluesseln = `${sops} --encrypt --filename-override %f /dev/stdin`;
+    return {
+        clean: wrapper === undefined ? verschluesseln : `${shellWort(wrapper)} %f ${verschluesseln}`,
+        smudge: `${sops} --decrypt --filename-override %f /dev/stdin`,
+    };
+}
+/** Der erste ausführbare Kandidat für sops-clean.sh, sonst undefined. */
+export async function wrapperFinden(kandidaten) {
+    for (const kandidat of kandidaten) {
+        const ausfuehrbar = await access(kandidat, constants.X_OK).then(() => true, () => false);
+        if (ausfuehrbar)
+            return kandidat;
+    }
+    return undefined;
+}
+/**
+ * Entschlüsselt `inhalt` probeweise so, wie es der smudge-Filter täte. Der Klartext wird verworfen,
+ * es zählt nur der Exit-Code. Fehlt das Programm, heißt das „sops fehlt", kein Absturz.
+ */
+export async function probe(programm, datei, inhalt) {
+    return await new Promise((erfuellen) => {
+        let fertig = false;
+        const ende = (ergebnis) => {
+            if (fertig)
+                return;
+            fertig = true;
+            erfuellen(ergebnis);
+        };
+        const kind = spawn(programm, ['--decrypt', '--filename-override', datei, '/dev/stdin'], {
+            stdio: ['pipe', 'ignore', 'ignore'],
+            timeout: 60_000,
+            killSignal: 'SIGKILL',
+        });
+        kind.on('error', (fehler) => ende({ ok: false, grund: fehler.code === 'ENOENT' ? 'sops-fehlt' : 'entschluesselung-scheitert' }));
+        kind.on('close', (code) => ende(code === 0 ? { ok: true } : { ok: false, grund: 'entschluesselung-scheitert' }));
+        // Endet sops vor dem Lesen, schreibt Node in eine geschlossene Pipe: das ist kein eigener Fehler.
+        kind.stdin.on('error', () => { });
+        kind.stdin.end(inhalt);
+    });
+}
+/**
+ * Fehlertext für einen gescheiterten git-Aufruf beim Nachziehen (E115): Scheitert er an einem
+ * SOPS-Filter, steht vorn ein verständlicher Satz, die Meldung von git folgt dahinter.
+ */
+export function sopsFehlertext(fehler) {
+    const meldung = fehler instanceof Error ? fehler.message : String(fehler);
+    // git meldet je nach Sprache anders; sicher drin stehen der Filtername oder der sops-Befehl.
+    if (!/sops_(?:dotenv|yaml|generic)|--decrypt --filename-override/.test(meldung))
+        return meldung;
+    return `Eine mit SOPS verschlüsselte Datei ließ sich nicht entschlüsseln (sops fehlt oder der Schlüssel passt nicht), dieser Checkout wurde nicht nachgezogen. git meldet: ${meldung}`;
+}
+/** Ausgabe von `git check-attr -z … filter`: je Datei drei NUL-getrennte Felder Pfad, Attribut, Wert. */
+export function checkAttrLesen(ausgabe) {
+    const teile = ausgabe.split('\0');
+    const ergebnis = new Map();
+    for (let i = 0; i + 2 < teile.length; i += 3)
+        ergebnis.set(teile[i], teile[i + 2]);
+    return ergebnis;
+}
+/**
+ * Welche Dateien ein Sparse-Checkout mit diesen Mustern schreibt (E11): `/*` die Dateien an der
+ * Wurzel, `/**` alles, `/<pfad>/` alles darunter. Ausschlüsse (`!…`) nehmen nur Verzeichnisse an
+ * der Wurzel heraus, die über `/*` ohnehin nicht als Datei zählen.
+ */
+export function musterAuswahl(muster) {
+    let wurzelDateien = false;
+    let alles = false;
+    const praefixe = [];
+    for (const m of muster) {
+        if (m === '/*')
+            wurzelDateien = true;
+        else if (m === '/**')
+            alles = true;
+        else if (!m.startsWith('!') && m.startsWith('/') && m.endsWith('/') && m.length > 2)
+            praefixe.push(m.slice(1));
+    }
+    return (datei) => alles || (wurzelDateien && !datei.includes('/')) || praefixe.some((praefix) => datei.startsWith(praefix));
+}

package/dist/adapter/zustand-json.js

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

package/dist/aenderungen.json

@@ -1,6 +1,12 @@
 {
   "fassung": 1,
   "versionen": {
+    "0.0.47": [
+      "Skills mit SOPS-verschlüsselten Dateien kommen jetzt entschlüsselt an, wenn sops, der passende Schlüssel und sops-clean.sh vorhanden sind; bereits verschlüsselt ausgecheckte Dateien repariert hmgr beim nächsten Aktualisieren. Klappt das nicht, bleibt die Datei verschlüsselt und hmgr sagt im Verlauf und in hmgr status, warum."
+    ],
+    "0.0.46": [
+      "Bundles lassen sich aufklappen und zeigen ihre Skills mit Beschreibung, auch schon im Dialog „Skills hinzufügen“. Entfernst du einen einzelnen Skill, bleibt das Bundle bestehen und zeigt, was fehlt; mit „Vervollständigen“ oder „Wieder verlinken“ holst du Skills zurück, und „Entfernen“ am Bundle räumt den Rest weg."
+    ],
     "0.0.45": [
       "MCP-Server und die Listen in den Einstellungen (Harnesses, zusätzliche Homedirs) erscheinen jetzt alphabetisch sortiert, ebenso in hmgr mcp list."
     ],

package/dist/cli/hilfe.js

@@ -315,9 +315,13 @@ Liegt am Ziel schon derselbe Skill aus derselben Quelle als hmgr-Link, wird er a
 übernommen: aus Bestand wird ein Bundle, ohne erst Links von Hand zu entfernen. Alles andere unter
 demselben Namen ist ein Konflikt und wird genannt.
 
-hmgr unlink <skill> auf ein einzelnes Mitglied zerbricht das Bundle in diesem Ziel: die übrigen
-Links bleiben als einzelne Links liegen, der Bundle-Verweis fällt weg. Das ist kein Fehler, hmgr
-sagt es nur.
+hmgr unlink <skill> auf ein einzelnes Mitglied nimmt es aus dem Bundle heraus: nur dieser Link
+verschwindet, das Bundle bleibt im Ziel und merkt sich den Skill als herausgenommen. sync und
+update legen ihn nicht wieder an, neue Mitglieder der Definition ergänzen sie weiter. Zurück kommt
+er mit hmgr link <skill> desselben Skills aus derselben Quelle oder mit bundle sync --complete, das
+alle fehlenden Mitglieder verlinkt. remove nimmt die noch verlinkten Mitglieder weg, auch wenn
+schon welche herausgenommen sind. hmgr status und bundle list zeigen die Lage je Ziel, etwa
+„4/5 … fehlt: x".
 
 Den Abgleich macht schon hmgr update für alle installierten Bundles mit, es ist derselbe Vorgang
 und dieselbe Ausgabe (E69): eine geänderte Definition kommt also mit dem gewöhnlichen
@@ -335,11 +339,14 @@ Schalter (add, remove und sync):
                       kennt nur hermes, wsl:<distro> nur claude-code unter Windows (E78)
   --composer <pfad>   composer.json des Arbeitsverzeichnisses, wenn mehrere in Frage kommen
   --quelle <teil>     nur bei add: Quelle eingrenzen, wenn den Namen mehrere Quellen führen
+  --complete          nur bei sync: auch herausgenommene Mitglieder verlinken (Vervollständigen),
+                      die Liste der herausgenommenen ist danach leer. Auch --vervollstaendigen
 
 Beispiele:
   hmgr bundle list
   hmgr bundle add wordpress --ort dir:.
   hmgr bundle sync
+  hmgr bundle sync wordpress --ort dir:. --complete
   hmgr bundle remove wordpress --ort dir:.
 
 Häufige Fälle:
@@ -524,7 +531,9 @@ ohne den übrigen Lauf aufzuhalten. hmgr bundle sync macht dasselbe für ein ein
 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
-gemeldet. Ein verwaister Checkout mit lokaler Änderung wird nie gelöscht (E15).
+gemeldet. Ein verwaister Checkout mit lokaler Änderung wird nie gelöscht (E15). Danach folgen die
+Prüfungen von hmgr doctor: fehlende Arbeitsverzeichnisse und mit SOPS verschlüsselte Dateien, die
+noch verschlüsselt im Checkout liegen (siehe hmgr help doctor).
 
 So wird eine Änderung an einem Skill überall wirksam: in der Quelle committen und pushen, dann
 hmgr update.
@@ -544,7 +553,8 @@ Eingeschränkter Lauf (E89): hmgr update <skill> zieht nur die Quelle nach, in d
 von URL, Pfad oder Anzeigenamen der Quelle, Groß- und Kleinschreibung egal; passt keine oder
 mehr als eine, bricht update mit der Liste ab. Beides zusammen geht nicht. Der Lauf umfasst die
 Checkouts dieser Quelle und die Bundles, deren Definition in ihr liegt. Es entfallen: Plugins,
-Aufräumen verwaister Checkouts, der Check auf fehlende Arbeitsverzeichnisse (doctor) sowie alle
+Aufräumen verwaister Checkouts, die doctor-Prüfungen (fehlende Arbeitsverzeichnisse,
+verschlüsselte SOPS-Dateien) sowie alle
 übrigen Quellen und Bundles. Der Verlaufseintrag entsteht wie im vollen Lauf.
 
 Schalter:
@@ -580,7 +590,10 @@ ausgecheckte Skills (E70). Quellen ohne Skill-Änderung sammelt eine Zeile am En
 Ereignisse, je eine Zeile: ein nachgezogenes Bundle mit gelegten und entfernten Links, ein
 aufgeräumter (gelöschter) Checkout, ein Fehler zu einer Quelle oder einem Bundle, dazu
 hmgr-Ereignisse: ein Versionssprung von hmgr selbst (GUI oder CLI, erkannt beim Start bzw. bei
-jedem CLI-Aufruf) oder ein gefundenes Update, das noch nicht installiert ist. Einträge aus der
+jedem CLI-Aufruf) oder ein gefundenes Update, das noch nicht installiert ist. Dazu Dateien, die
+eine Quelle mit SOPS verschlüsselt: eine, die verschlüsselt im Checkout blieb, mit Grund (einmal,
+auch direkt nach einem hmgr link), und eine, die hmgr nachträglich entschlüsselt hat (siehe
+hmgr help doctor). Einträge aus der
 Zeit vor E109 zeigen nur „Geändert". Plugins stehen nicht im Verlauf (siehe hmgr help update).
 
 Unter einem „installiert"-Eintrag von hmgr stehen die Änderungen: je Version seit der zuvor
@@ -604,8 +617,21 @@ Prüft, ob jedes gemerkte Arbeitsverzeichnis (hmgr dir add) noch auf der Platte
 umbenanntes oder woanders neu geklontes Projekt hinterlässt sonst für immer einen toten Pfad im
 Zustand, den nur hmgr dir forget von Hand entfernt. Bei einem Fund fragt doctor wie hmgr update
 einmal für alle Funde, ob sie vergessen werden sollen; ohne Bestätigung bleiben sie gemeldet, aber
-gemerkt. Anders als update holt doctor nichts aus dem Netz und schreibt keinen Eintrag in den
-Verlauf — ein reiner Konsolen-Check, kein Lauf im E80-Sinn.
+gemerkt. Anders als update holt doctor nichts aus dem Netz.
+
+Dazu prüft doctor Dateien, die eine Quelle mit SOPS verschlüsselt (.gitattributes mit
+filter=sops_dotenv, sops_yaml oder sops_generic) und die noch verschlüsselt im Checkout liegen,
+etwa weil sie vor dieser Prüfung ausgecheckt wurden oder sops damals fehlte. Liegt
+sops-clean.sh unter /usr/local/bin oder ~/bin und klappt eine probeweise Entschlüsselung mit sops,
+richtet doctor die git-Filter für die Quelle ein (wie sops-setup.sh, mit sops-clean.sh) und
+schreibt die Datei entschlüsselt neu. Sonst bleibt die Datei, wie sie ist, und doctor nennt den
+Grund: sops-clean.sh fehlt, sops fehlt, der Schlüssel passt nicht, oder die Datei ist im Checkout
+von Hand geändert. Ohne sops-clean.sh richtet hmgr nie Filter ein, weil git die entschlüsselte
+Datei sonst sofort für geändert hielte und hmgr update den Checkout danach immer überspränge.
+Dieselbe Regel gilt schon beim ersten Auschecken (hmgr link).
+Diese Befunde stehen auch im Verlauf (hmgr log), eine verschlüsselt gebliebene Datei nur einmal.
+Fehlende Arbeitsverzeichnisse schreibt doctor nicht in den Verlauf. hmgr update macht dieselbe
+Prüfung im selben Lauf.
 
 Schalter: keine.
 
@@ -615,6 +641,11 @@ Beispiel:
 Häufige Fälle:
   „liegen lassen … ohne Bestätigung nicht vergessen": die Frage kam ohne Ja zurück. In einem
   Terminal erneut hmgr doctor aufrufen, oder hmgr dir forget <pfad> gezielt.
+  „verschlüsselt … sops-clean.sh fehlt": sops-clean.sh ausführbar nach ~/bin oder
+  /usr/local/bin legen, dann erneut hmgr doctor.
+  „verschlüsselt … sops ist auf diesem Rechner nicht installiert": sops installieren, dann erneut
+  hmgr doctor. „… vermutlich fehlt der passende Schlüssel": der Schlüssel dieses Rechners steht
+  nicht unter den Empfängern der Datei, oder sops findet ihn nicht.
 
 Siehe auch: hmgr help update, hmgr help dir`;
 const STATUS = `hmgr status
@@ -624,7 +655,8 @@ und Ref, davor die Versionseinschränkung, falls der Zeiger eine nennt. Dahinter
 abgeleitete Grund des Links: das Plugin, zu dem er gehört, oder „über Zeiger", von Hand gelegte
 Links bleiben ohne Zusatz. Fremde Einträge und Links ohne bekannte Quelle sind eigens
 gekennzeichnet, dazu kommen die Plugins des Ziels. Am Ende stehen die Harnesses, die auf diesem
-Rechner nicht liegen.
+Rechner nicht liegen, und, falls es welche gibt, mit SOPS verschlüsselte Dateien, die noch
+verschlüsselt im Checkout liegen. status repariert nichts, das macht hmgr doctor.
 
 Schalter: keine.
 
@@ -637,10 +669,12 @@ Häufige Fälle:
   Zustand steht. Mit hmgr source add <url> die Quelle wieder eintragen.
   „Nicht vorhanden": der Harness hat sein Verzeichnis auf diesem Rechner nicht angelegt, hmgr
   überspringt seine Ziele.
+  „Noch verschlüsselt im Checkout": hmgr doctor versucht, die Datei zu entschlüsseln, und nennt
+  den Grund, wenn es nicht klappt.
   Ein Ziel fehlt: Ziele inaktiver Harness-Typen zeigt status nicht, auch wenn dort noch Links
   liegen. hmgr harness list zeigt den Stand, hmgr harness enable <name> holt die Ziele zurück.
 
-Siehe auch: hmgr help adopt, hmgr help sync`;
+Siehe auch: hmgr help adopt, hmgr help sync, hmgr help doctor`;
 const HARNESS = `hmgr harness list
 hmgr harness enable <name>
 hmgr harness disable <name>